/*
 * Copyright 2018 JDCLOUD.COM
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http:#www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * JDCLOUD CDN Operation And Query API
 * API related to CDN instances
 *
 * OpenAPI spec version: v1
 * Contact: 
 *
 * NOTE: This class is auto generated by the jdcloud code generator program.
 */


using JDCloudSDK.Core.Auth;
using JDCloudSDK.Core.Client;
using JDCloudSDK.Core.Http;
using JDCloudSDK.Cdn.Apis;
using JDCloudSDK.Cdn.Model;
using System;
using System.Collections.Generic;
using System.Text;
#if NET40||NET35
#else
using System.Threading.Tasks;
#endif

namespace JDCloudSDK.Cdn.Client
{
    /// <summary>
    ///  JDCLOUD CDN Operation And Query API
    ///  API related to CDN instances
    ///  Cdn Api 客户端
    ///</summary>
    public class CdnClient : JdcloudClient
    {

        /// <summary>
        ///  默认私有构造函数
        /// </summary>
        private CdnClient()
        {

        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        /// <param name="credentialsProvider">认证信息</param>
        /// <param name="httpRequestConfig">http 客户端配置信息</param>
        /// <param name="environment">sdk 环境配置信息</param>
        public CdnClient(CredentialsProvider credentialsProvider, HttpRequestConfig httpRequestConfig,SDKEnvironment environment)
        {
            this.httpRequestConfig = httpRequestConfig;
            this.credentialsProvider = credentialsProvider;
            this.environment = environment;
        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        /// <param name="httpRequestConfig">http 客户端配置信息</param>
        /// <param name="credentialsProvider">认证信息</param>
        public CdnClient(CredentialsProvider credentialsProvider,HttpRequestConfig httpRequestConfig)
        {
            this.httpRequestConfig = httpRequestConfig;
            this.credentialsProvider = credentialsProvider;
        }

        /// <summary>
        /// 默认构造函数，
        /// 注意如果使用此方法 httpRequestConfig 使用的http 请求 schema 为Https
        /// </summary>
        /// <param name="credentialsProvider">认证信息</param>
        public CdnClient(CredentialsProvider credentialsProvider)
        {
            this.credentialsProvider = credentialsProvider;
        }

        /// <summary>
        ///  版本号 1.2.8
        ///</summary>
        public const string ClientVersion = "1.2.8";

        private const string apiVersion = "v1";
        private const string userAgentPrefix = "JdcloudSdkDotNet";
        private const string defaultEndpoint = "cdn.jdcloud-api.com";
        private const string serviceName = "cdn";
        private const string userAgent = userAgentPrefix + "/" + ClientVersion + " " + serviceName + "/" + apiVersion;


        private SDKEnvironment environment = new SDKEnvironment(defaultEndpoint);
        private CredentialsProvider credentialsProvider;
        private HttpRequestConfig httpRequestConfig;

        /// <summary>
        ///  获取证书信息
        ///</summary>
        public override CredentialsProvider CredentialsProvider   { get { return credentialsProvider; } }

        /// <summary>
        ///  获取http 客户端配置信息
        ///</summary>
        public override HttpRequestConfig HttpRequestConfig { get { return httpRequestConfig; } }

        /// <summary>
        ///  获取sdk环境配置信息
        ///</summary>
        public override SDKEnvironment SDKEnvironment { get { return environment; } }

        /// <summary>
        ///  获取用户自定义浏览器识别字符串
        ///</summary>
        public override string UserAgent { get { return userAgent; } }

        /// <summary>
        ///  获取服务名称
        ///</summary>
        public override string ServiceName { get { return serviceName; } }

        /// <summary>
        ///  获取版本号
        ///</summary>
        public override string Version { get { return apiVersion; } }



#if NET40||NET35
        /// <summary>
        ///  设置线上计费方式
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetOnlineBillingTypeResponse SetOnlineBillingType(SetOnlineBillingTypeRequest request) {
            return  new SetOnlineBillingTypeExecutor().Client(this).Execute<SetOnlineBillingTypeResponse, SetOnlineBillingTypeResult, SetOnlineBillingTypeRequest>(request);
        }
#else
        /// <summary>
        ///  设置线上计费方式
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetOnlineBillingTypeResponse> SetOnlineBillingType(SetOnlineBillingTypeRequest request) {
            return await new SetOnlineBillingTypeExecutor().Client(this).Execute<SetOnlineBillingTypeResponse, SetOnlineBillingTypeResult, SetOnlineBillingTypeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询用户服务通知接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryServiceNoticeResponse QueryServiceNotice(QueryServiceNoticeRequest request) {
            return  new QueryServiceNoticeExecutor().Client(this).Execute<QueryServiceNoticeResponse, QueryServiceNoticeResult, QueryServiceNoticeRequest>(request);
        }
#else
        /// <summary>
        ///  查询用户服务通知接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryServiceNoticeResponse> QueryServiceNotice(QueryServiceNoticeRequest request) {
            return await new QueryServiceNoticeExecutor().Client(this).Execute<QueryServiceNoticeResponse, QueryServiceNoticeResult, QueryServiceNoticeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询设备状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDeviceStatusForPCdnResponse QueryDeviceStatusForPCdn(QueryDeviceStatusForPCdnRequest request) {
            return  new QueryDeviceStatusForPCdnExecutor().Client(this).Execute<QueryDeviceStatusForPCdnResponse, QueryDeviceStatusForPCdnResult, QueryDeviceStatusForPCdnRequest>(request);
        }
#else
        /// <summary>
        ///  查询设备状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDeviceStatusForPCdnResponse> QueryDeviceStatusForPCdn(QueryDeviceStatusForPCdnRequest request) {
            return await new QueryDeviceStatusForPCdnExecutor().Client(this).Execute<QueryDeviceStatusForPCdnResponse, QueryDeviceStatusForPCdnResult, QueryDeviceStatusForPCdnRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询目录基础统计数据，仅有部分用户支持该功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDirStatsDataResponse QueryDirStatsData(QueryDirStatsDataRequest request) {
            return  new QueryDirStatsDataExecutor().Client(this).Execute<QueryDirStatsDataResponse, QueryDirStatsDataResult, QueryDirStatsDataRequest>(request);
        }
#else
        /// <summary>
        ///  查询目录基础统计数据，仅有部分用户支持该功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDirStatsDataResponse> QueryDirStatsData(QueryDirStatsDataRequest request) {
            return await new QueryDirStatsDataExecutor().Client(this).Execute<QueryDirStatsDataResponse, QueryDirStatsDataResult, QueryDirStatsDataRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询域名组详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainGroupDetailResponse QueryDomainGroupDetail(QueryDomainGroupDetailRequest request) {
            return  new QueryDomainGroupDetailExecutor().Client(this).Execute<QueryDomainGroupDetailResponse, QueryDomainGroupDetailResult, QueryDomainGroupDetailRequest>(request);
        }
#else
        /// <summary>
        ///  查询域名组详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainGroupDetailResponse> QueryDomainGroupDetail(QueryDomainGroupDetailRequest request) {
            return await new QueryDomainGroupDetailExecutor().Client(this).Execute<QueryDomainGroupDetailResponse, QueryDomainGroupDetailResult, QueryDomainGroupDetailRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询模板详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainTempProKeysResponse QueryDomainTempProKeys(QueryDomainTempProKeysRequest request) {
            return  new QueryDomainTempProKeysExecutor().Client(this).Execute<QueryDomainTempProKeysResponse, QueryDomainTempProKeysResult, QueryDomainTempProKeysRequest>(request);
        }
#else
        /// <summary>
        ///  查询模板详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainTempProKeysResponse> QueryDomainTempProKeys(QueryDomainTempProKeysRequest request) {
            return await new QueryDomainTempProKeysExecutor().Client(this).Execute<QueryDomainTempProKeysResponse, QueryDomainTempProKeysResult, QueryDomainTempProKeysRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询WAF黑名单开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryWafBlackRuleSwitchResponse QueryWafBlackRuleSwitch(QueryWafBlackRuleSwitchRequest request) {
            return  new QueryWafBlackRuleSwitchExecutor().Client(this).Execute<QueryWafBlackRuleSwitchResponse, QueryWafBlackRuleSwitchResult, QueryWafBlackRuleSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  查询WAF黑名单开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryWafBlackRuleSwitchResponse> QueryWafBlackRuleSwitch(QueryWafBlackRuleSwitchRequest request) {
            return await new QueryWafBlackRuleSwitchExecutor().Client(this).Execute<QueryWafBlackRuleSwitchResponse, QueryWafBlackRuleSwitchResult, QueryWafBlackRuleSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除httpHeader
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteHttpHeaderResponse DeleteHttpHeader(DeleteHttpHeaderRequest request) {
            return  new DeleteHttpHeaderExecutor().Client(this).Execute<DeleteHttpHeaderResponse, DeleteHttpHeaderResult, DeleteHttpHeaderRequest>(request);
        }
#else
        /// <summary>
        ///  删除httpHeader
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteHttpHeaderResponse> DeleteHttpHeader(DeleteHttpHeaderRequest request) {
            return await new DeleteHttpHeaderExecutor().Client(this).Execute<DeleteHttpHeaderResponse, DeleteHttpHeaderResult, DeleteHttpHeaderRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置自定义错误页面信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetCustomErrorPageResponse SetCustomErrorPage(SetCustomErrorPageRequest request) {
            return  new SetCustomErrorPageExecutor().Client(this).Execute<SetCustomErrorPageResponse, SetCustomErrorPageResult, SetCustomErrorPageRequest>(request);
        }
#else
        /// <summary>
        ///  设置自定义错误页面信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetCustomErrorPageResponse> SetCustomErrorPage(SetCustomErrorPageRequest request) {
            return await new SetCustomErrorPageExecutor().Client(this).Execute<SetCustomErrorPageResponse, SetCustomErrorPageResult, SetCustomErrorPageRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  禁用WAF黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableWafBlackRulesResponse DisableWafBlackRules(DisableWafBlackRulesRequest request) {
            return  new DisableWafBlackRulesExecutor().Client(this).Execute<DisableWafBlackRulesResponse, DisableWafBlackRulesResult, DisableWafBlackRulesRequest>(request);
        }
#else
        /// <summary>
        ///  禁用WAF黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableWafBlackRulesResponse> DisableWafBlackRules(DisableWafBlackRulesRequest request) {
            return await new DisableWafBlackRulesExecutor().Client(this).Execute<DisableWafBlackRulesResponse, DisableWafBlackRulesResult, DisableWafBlackRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryWebProtectSettingsResponse QueryWebProtectSettings(QueryWebProtectSettingsRequest request) {
            return  new QueryWebProtectSettingsExecutor().Client(this).Execute<QueryWebProtectSettingsResponse, QueryWebProtectSettingsResult, QueryWebProtectSettingsRequest>(request);
        }
#else
        /// <summary>
        ///  查询web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryWebProtectSettingsResponse> QueryWebProtectSettings(QueryWebProtectSettingsRequest request) {
            return await new QueryWebProtectSettingsExecutor().Client(this).Execute<QueryWebProtectSettingsResponse, QueryWebProtectSettingsResult, QueryWebProtectSettingsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询geo地域
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryGeoAreasResponse QueryGeoAreas(QueryGeoAreasRequest request) {
            return  new QueryGeoAreasExecutor().Client(this).Execute<QueryGeoAreasResponse, QueryGeoAreasResult, QueryGeoAreasRequest>(request);
        }
#else
        /// <summary>
        ///  查询geo地域
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryGeoAreasResponse> QueryGeoAreas(QueryGeoAreasRequest request) {
            return await new QueryGeoAreasExecutor().Client(this).Execute<QueryGeoAreasResponse, QueryGeoAreasResult, QueryGeoAreasRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询TOP Url，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryStatisticsTopUrlResponse QueryStatisticsTopUrl(QueryStatisticsTopUrlRequest request) {
            return  new QueryStatisticsTopUrlExecutor().Client(this).Execute<QueryStatisticsTopUrlResponse, QueryStatisticsTopUrlResult, QueryStatisticsTopUrlRequest>(request);
        }
#else
        /// <summary>
        ///  查询TOP Url，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryStatisticsTopUrlResponse> QueryStatisticsTopUrl(QueryStatisticsTopUrlRequest request) {
            return await new QueryStatisticsTopUrlExecutor().Client(this).Execute<QueryStatisticsTopUrlResponse, QueryStatisticsTopUrlResult, QueryStatisticsTopUrlRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询域名配置状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainConfigStatusResponse QueryDomainConfigStatus(QueryDomainConfigStatusRequest request) {
            return  new QueryDomainConfigStatusExecutor().Client(this).Execute<QueryDomainConfigStatusResponse, QueryDomainConfigStatusResult, QueryDomainConfigStatusRequest>(request);
        }
#else
        /// <summary>
        ///  查询域名配置状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainConfigStatusResponse> QueryDomainConfigStatus(QueryDomainConfigStatusRequest request) {
            return await new QueryDomainConfigStatusExecutor().Client(this).Execute<QueryDomainConfigStatusResponse, QueryDomainConfigStatusResult, QueryDomainConfigStatusRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  获取所有上层节点的ip
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetAllUpperNodeIpListResponse GetAllUpperNodeIpList(GetAllUpperNodeIpListRequest request) {
            return  new GetAllUpperNodeIpListExecutor().Client(this).Execute<GetAllUpperNodeIpListResponse, GetAllUpperNodeIpListResult, GetAllUpperNodeIpListRequest>(request);
        }
#else
        /// <summary>
        ///  获取所有上层节点的ip
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetAllUpperNodeIpListResponse> GetAllUpperNodeIpList(GetAllUpperNodeIpListRequest request) {
            return await new GetAllUpperNodeIpListExecutor().Client(this).Execute<GetAllUpperNodeIpListResponse, GetAllUpperNodeIpListResult, GetAllUpperNodeIpListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  分地区及运营商查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLiveStatisticsAreaDataGroupByResponse QueryLiveStatisticsAreaDataGroupBy(QueryLiveStatisticsAreaDataGroupByRequest request) {
            return  new QueryLiveStatisticsAreaDataGroupByExecutor().Client(this).Execute<QueryLiveStatisticsAreaDataGroupByResponse, QueryLiveStatisticsAreaDataGroupByResult, QueryLiveStatisticsAreaDataGroupByRequest>(request);
        }
#else
        /// <summary>
        ///  分地区及运营商查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLiveStatisticsAreaDataGroupByResponse> QueryLiveStatisticsAreaDataGroupBy(QueryLiveStatisticsAreaDataGroupByRequest request) {
            return await new QueryLiveStatisticsAreaDataGroupByExecutor().Client(this).Execute<QueryLiveStatisticsAreaDataGroupByResponse, QueryLiveStatisticsAreaDataGroupByResult, QueryLiveStatisticsAreaDataGroupByRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置ip黑名白单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetIpBlackListResponse SetIpBlackList(SetIpBlackListRequest request) {
            return  new SetIpBlackListExecutor().Client(this).Execute<SetIpBlackListResponse, SetIpBlackListResult, SetIpBlackListRequest>(request);
        }
#else
        /// <summary>
        ///  设置ip黑名白单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetIpBlackListResponse> SetIpBlackList(SetIpBlackListRequest request) {
            return await new SetIpBlackListExecutor().Client(this).Execute<SetIpBlackListResponse, SetIpBlackListResult, SetIpBlackListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改指定的白名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateWafWhiteRuleResponse UpdateWafWhiteRule(UpdateWafWhiteRuleRequest request) {
            return  new UpdateWafWhiteRuleExecutor().Client(this).Execute<UpdateWafWhiteRuleResponse, UpdateWafWhiteRuleResult, UpdateWafWhiteRuleRequest>(request);
        }
#else
        /// <summary>
        ///  修改指定的白名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateWafWhiteRuleResponse> UpdateWafWhiteRule(UpdateWafWhiteRuleRequest request) {
            return await new UpdateWafWhiteRuleExecutor().Client(this).Execute<UpdateWafWhiteRuleResponse, UpdateWafWhiteRuleResult, UpdateWafWhiteRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  更新域名配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetDomainConfigResponse SetDomainConfig(SetDomainConfigRequest request) {
            return  new SetDomainConfigExecutor().Client(this).Execute<SetDomainConfigResponse, SetDomainConfigResult, SetDomainConfigRequest>(request);
        }
#else
        /// <summary>
        ///  更新域名配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetDomainConfigResponse> SetDomainConfig(SetDomainConfigRequest request) {
            return await new SetDomainConfigExecutor().Client(this).Execute<SetDomainConfigResponse, SetDomainConfigResult, SetDomainConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询定制的目录带宽，仅有部分用户支持该功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryCustomizedDirBandWidthResponse QueryCustomizedDirBandWidth(QueryCustomizedDirBandWidthRequest request) {
            return  new QueryCustomizedDirBandWidthExecutor().Client(this).Execute<QueryCustomizedDirBandWidthResponse, QueryCustomizedDirBandWidthResult, QueryCustomizedDirBandWidthRequest>(request);
        }
#else
        /// <summary>
        ///  查询定制的目录带宽，仅有部分用户支持该功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryCustomizedDirBandWidthResponse> QueryCustomizedDirBandWidth(QueryCustomizedDirBandWidthRequest request) {
            return await new QueryCustomizedDirBandWidthExecutor().Client(this).Execute<QueryCustomizedDirBandWidthResponse, QueryCustomizedDirBandWidthResult, QueryCustomizedDirBandWidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置用户刷新预热限额
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetRefreshLimitResponse SetRefreshLimit(SetRefreshLimitRequest request) {
            return  new SetRefreshLimitExecutor().Client(this).Execute<SetRefreshLimitResponse, SetRefreshLimitResult, SetRefreshLimitRequest>(request);
        }
#else
        /// <summary>
        ///  设置用户刷新预热限额
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetRefreshLimitResponse> SetRefreshLimit(SetRefreshLimitRequest request) {
            return await new SetRefreshLimitExecutor().Client(this).Execute<SetRefreshLimitResponse, SetRefreshLimitResult, SetRefreshLimitRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置回源302跳转
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetFollowRedirectResponse SetFollowRedirect(SetFollowRedirectRequest request) {
            return  new SetFollowRedirectExecutor().Client(this).Execute<SetFollowRedirectResponse, SetFollowRedirectResult, SetFollowRedirectRequest>(request);
        }
#else
        /// <summary>
        ///  设置回源302跳转
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetFollowRedirectResponse> SetFollowRedirect(SetFollowRedirectRequest request) {
            return await new SetFollowRedirectExecutor().Client(this).Execute<SetFollowRedirectResponse, SetFollowRedirectResult, SetFollowRedirectRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  启动加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StartDomainResponse StartDomain(StartDomainRequest request) {
            return  new StartDomainExecutor().Client(this).Execute<StartDomainResponse, StartDomainResult, StartDomainRequest>(request);
        }
#else
        /// <summary>
        ///  启动加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StartDomainResponse> StartDomain(StartDomainRequest request) {
            return await new StartDomainExecutor().Client(this).Execute<StartDomainResponse, StartDomainResult, StartDomainRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  分地域运营商带宽查询接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryBandWithAreaResponse QueryBandWithArea(QueryBandWithAreaRequest request) {
            return  new QueryBandWithAreaExecutor().Client(this).Execute<QueryBandWithAreaResponse, QueryBandWithAreaResult, QueryBandWithAreaRequest>(request);
        }
#else
        /// <summary>
        ///  分地域运营商带宽查询接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryBandWithAreaResponse> QueryBandWithArea(QueryBandWithAreaRequest request) {
            return await new QueryBandWithAreaExecutor().Client(this).Execute<QueryBandWithAreaResponse, QueryBandWithAreaResult, QueryBandWithAreaRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置url鉴权
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetAccesskeyConfigResponse SetAccesskeyConfig(SetAccesskeyConfigRequest request) {
            return  new SetAccesskeyConfigExecutor().Client(this).Execute<SetAccesskeyConfigResponse, SetAccesskeyConfigResult, SetAccesskeyConfigRequest>(request);
        }
#else
        /// <summary>
        ///  设置url鉴权
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetAccesskeyConfigResponse> SetAccesskeyConfig(SetAccesskeyConfigRequest request) {
            return await new SetAccesskeyConfigExecutor().Client(this).Execute<SetAccesskeyConfigResponse, SetAccesskeyConfigResult, SetAccesskeyConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置range参数
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetRangeResponse SetRange(SetRangeRequest request) {
            return  new SetRangeExecutor().Client(this).Execute<SetRangeResponse, SetRangeResult, SetRangeRequest>(request);
        }
#else
        /// <summary>
        ///  设置range参数
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetRangeResponse> SetRange(SetRangeRequest request) {
            return await new SetRangeExecutor().Client(this).Execute<SetRangeResponse, SetRangeResult, SetRangeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置直播域名ip黑白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetLiveDomainIpBlackListResponse SetLiveDomainIpBlackList(SetLiveDomainIpBlackListRequest request) {
            return  new SetLiveDomainIpBlackListExecutor().Client(this).Execute<SetLiveDomainIpBlackListResponse, SetLiveDomainIpBlackListResult, SetLiveDomainIpBlackListRequest>(request);
        }
#else
        /// <summary>
        ///  设置直播域名ip黑白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetLiveDomainIpBlackListResponse> SetLiveDomainIpBlackList(SetLiveDomainIpBlackListRequest request) {
            return await new SetLiveDomainIpBlackListExecutor().Client(this).Execute<SetLiveDomainIpBlackListResponse, SetLiveDomainIpBlackListResult, SetLiveDomainIpBlackListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置CC 防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetCCProtectSwitchResponse SetCCProtectSwitch(SetCCProtectSwitchRequest request) {
            return  new SetCCProtectSwitchExecutor().Client(this).Execute<SetCCProtectSwitchResponse, SetCCProtectSwitchResult, SetCCProtectSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  设置CC 防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetCCProtectSwitchResponse> SetCCProtectSwitch(SetCCProtectSwitchRequest request) {
            return await new SetCCProtectSwitchExecutor().Client(this).Execute<SetCCProtectSwitchResponse, SetCCProtectSwitchResult, SetCCProtectSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetExtraCacheTimeResponse SetExtraCacheTime(SetExtraCacheTimeRequest request) {
            return  new SetExtraCacheTimeExecutor().Client(this).Execute<SetExtraCacheTimeResponse, SetExtraCacheTimeResult, SetExtraCacheTimeRequest>(request);
        }
#else
        /// <summary>
        ///  设置异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetExtraCacheTimeResponse> SetExtraCacheTime(SetExtraCacheTimeRequest request) {
            return await new SetExtraCacheTimeExecutor().Client(this).Execute<SetExtraCacheTimeResponse, SetExtraCacheTimeResult, SetExtraCacheTimeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询源站监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryMonitorResponse QueryMonitor(QueryMonitorRequest request) {
            return  new QueryMonitorExecutor().Client(this).Execute<QueryMonitorResponse, QueryMonitorResult, QueryMonitorRequest>(request);
        }
#else
        /// <summary>
        ///  查询源站监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryMonitorResponse> QueryMonitor(QueryMonitorRequest request) {
            return await new QueryMonitorExecutor().Client(this).Execute<QueryMonitorResponse, QueryMonitorResult, QueryMonitorRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询用户刷新预热封禁限额
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryCdnUserQuotaResponse QueryCdnUserQuota(QueryCdnUserQuotaRequest request) {
            return  new QueryCdnUserQuotaExecutor().Client(this).Execute<QueryCdnUserQuotaResponse, QueryCdnUserQuotaResult, QueryCdnUserQuotaRequest>(request);
        }
#else
        /// <summary>
        ///  查询用户刷新预热封禁限额
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryCdnUserQuotaResponse> QueryCdnUserQuota(QueryCdnUserQuotaRequest request) {
            return await new QueryCdnUserQuotaExecutor().Client(this).Execute<QueryCdnUserQuotaResponse, QueryCdnUserQuotaResult, QueryCdnUserQuotaRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询直播域名app列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLiveDomainAppsResponse QueryLiveDomainApps(QueryLiveDomainAppsRequest request) {
            return  new QueryLiveDomainAppsExecutor().Client(this).Execute<QueryLiveDomainAppsResponse, QueryLiveDomainAppsResult, QueryLiveDomainAppsRequest>(request);
        }
#else
        /// <summary>
        ///  查询直播域名app列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLiveDomainAppsResponse> QueryLiveDomainApps(QueryLiveDomainAppsRequest request) {
            return await new QueryLiveDomainAppsExecutor().Client(this).Execute<QueryLiveDomainAppsResponse, QueryLiveDomainAppsResult, QueryLiveDomainAppsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  禁用WAF白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableWafWhiteRulesResponse DisableWafWhiteRules(DisableWafWhiteRulesRequest request) {
            return  new DisableWafWhiteRulesExecutor().Client(this).Execute<DisableWafWhiteRulesResponse, DisableWafWhiteRulesResult, DisableWafWhiteRulesRequest>(request);
        }
#else
        /// <summary>
        ///  禁用WAF白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableWafWhiteRulesResponse> DisableWafWhiteRules(DisableWafWhiteRulesRequest request) {
            return await new DisableWafWhiteRulesExecutor().Client(this).Execute<DisableWafWhiteRulesResponse, DisableWafWhiteRulesResult, DisableWafWhiteRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  新增一条黑名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateWafBlackRuleResponse CreateWafBlackRule(CreateWafBlackRuleRequest request) {
            return  new CreateWafBlackRuleExecutor().Client(this).Execute<CreateWafBlackRuleResponse, CreateWafBlackRuleResult, CreateWafBlackRuleRequest>(request);
        }
#else
        /// <summary>
        ///  新增一条黑名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateWafBlackRuleResponse> CreateWafBlackRule(CreateWafBlackRuleRequest request) {
            return await new CreateWafBlackRuleExecutor().Client(this).Execute<CreateWafBlackRuleResponse, CreateWafBlackRuleResult, CreateWafBlackRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建域名组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateDomainGroupResponse CreateDomainGroup(CreateDomainGroupRequest request) {
            return  new CreateDomainGroupExecutor().Client(this).Execute<CreateDomainGroupResponse, CreateDomainGroupResult, CreateDomainGroupRequest>(request);
        }
#else
        /// <summary>
        ///  创建域名组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateDomainGroupResponse> CreateDomainGroup(CreateDomainGroupRequest request) {
            return await new CreateDomainGroupExecutor().Client(this).Execute<CreateDomainGroupResponse, CreateDomainGroupResult, CreateDomainGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryWebProtectSwitchResponse QueryWebProtectSwitch(QueryWebProtectSwitchRequest request) {
            return  new QueryWebProtectSwitchExecutor().Client(this).Execute<QueryWebProtectSwitchResponse, QueryWebProtectSwitchResult, QueryWebProtectSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  查询web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryWebProtectSwitchResponse> QueryWebProtectSwitch(QueryWebProtectSwitchRequest request) {
            return await new QueryWebProtectSwitchExecutor().Client(this).Execute<QueryWebProtectSwitchResponse, QueryWebProtectSwitchResult, QueryWebProtectSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询攻击来源
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public WafQueryPvForAreaAndIpResponse WafQueryPvForAreaAndIp(WafQueryPvForAreaAndIpRequest request) {
            return  new WafQueryPvForAreaAndIpExecutor().Client(this).Execute<WafQueryPvForAreaAndIpResponse, WafQueryPvForAreaAndIpResult, WafQueryPvForAreaAndIpRequest>(request);
        }
#else
        /// <summary>
        ///  查询攻击来源
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<WafQueryPvForAreaAndIpResponse> WafQueryPvForAreaAndIp(WafQueryPvForAreaAndIpRequest request) {
            return await new WafQueryPvForAreaAndIpExecutor().Client(this).Execute<WafQueryPvForAreaAndIpResponse, WafQueryPvForAreaAndIpResult, WafQueryPvForAreaAndIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置ip黑名单状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public OperateIpBlackListResponse OperateIpBlackList(OperateIpBlackListRequest request) {
            return  new OperateIpBlackListExecutor().Client(this).Execute<OperateIpBlackListResponse, OperateIpBlackListResult, OperateIpBlackListRequest>(request);
        }
#else
        /// <summary>
        ///  设置ip黑名单状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<OperateIpBlackListResponse> OperateIpBlackList(OperateIpBlackListRequest request) {
            return await new OperateIpBlackListExecutor().Client(this).Execute<OperateIpBlackListResponse, OperateIpBlackListResult, OperateIpBlackListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询统计数据，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryMixStatisticsDataResponse QueryMixStatisticsData(QueryMixStatisticsDataRequest request) {
            return  new QueryMixStatisticsDataExecutor().Client(this).Execute<QueryMixStatisticsDataResponse, QueryMixStatisticsDataResult, QueryMixStatisticsDataRequest>(request);
        }
#else
        /// <summary>
        ///  查询统计数据，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryMixStatisticsDataResponse> QueryMixStatisticsData(QueryMixStatisticsDataRequest request) {
            return await new QueryMixStatisticsDataExecutor().Client(this).Execute<QueryMixStatisticsDataResponse, QueryMixStatisticsDataResult, QueryMixStatisticsDataRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询刷新预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryRefreshTaskResponse QueryRefreshTask(QueryRefreshTaskRequest request) {
            return  new QueryRefreshTaskExecutor().Client(this).Execute<QueryRefreshTaskResponse, QueryRefreshTaskResult, QueryRefreshTaskRequest>(request);
        }
#else
        /// <summary>
        ///  查询刷新预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryRefreshTaskResponse> QueryRefreshTask(QueryRefreshTaskRequest request) {
            return await new QueryRefreshTaskExecutor().Client(this).Execute<QueryRefreshTaskResponse, QueryRefreshTaskResult, QueryRefreshTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询http2配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryHttp2Response QueryHttp2(QueryHttp2Request request) {
            return  new QueryHttp2Executor().Client(this).Execute<QueryHttp2Response, QueryHttp2Result, QueryHttp2Request>(request);
        }
#else
        /// <summary>
        ///  查询http2配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryHttp2Response> QueryHttp2(QueryHttp2Request request) {
            return await new QueryHttp2Executor().Client(this).Execute<QueryHttp2Response, QueryHttp2Result, QueryHttp2Request>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询加速域名详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetDomainDetailResponse GetDomainDetail(GetDomainDetailRequest request) {
            return  new GetDomainDetailExecutor().Client(this).Execute<GetDomainDetailResponse, GetDomainDetailResult, GetDomainDetailRequest>(request);
        }
#else
        /// <summary>
        ///  查询加速域名详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetDomainDetailResponse> GetDomainDetail(GetDomainDetailRequest request) {
            return await new GetDomainDetailExecutor().Client(this).Execute<GetDomainDetailResponse, GetDomainDetailResult, GetDomainDetailRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置网络防护层规则总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetNetProtectionRulesSwitchResponse SetNetProtectionRulesSwitch(SetNetProtectionRulesSwitchRequest request) {
            return  new SetNetProtectionRulesSwitchExecutor().Client(this).Execute<SetNetProtectionRulesSwitchResponse, SetNetProtectionRulesSwitchResult, SetNetProtectionRulesSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  设置网络防护层规则总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetNetProtectionRulesSwitchResponse> SetNetProtectionRulesSwitch(SetNetProtectionRulesSwitchRequest request) {
            return await new SetNetProtectionRulesSwitchExecutor().Client(this).Execute<SetNetProtectionRulesSwitchResponse, SetNetProtectionRulesSwitchResult, SetNetProtectionRulesSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  http2配置，中国境外/全球加速域名暂不支持该配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ConfigHttp2Response ConfigHttp2(ConfigHttp2Request request) {
            return  new ConfigHttp2Executor().Client(this).Execute<ConfigHttp2Response, ConfigHttp2Result, ConfigHttp2Request>(request);
        }
#else
        /// <summary>
        ///  http2配置，中国境外/全球加速域名暂不支持该配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ConfigHttp2Response> ConfigHttp2(ConfigHttp2Request request) {
            return await new ConfigHttp2Executor().Client(this).Execute<ConfigHttp2Response, ConfigHttp2Result, ConfigHttp2Request>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  攻击记录查询
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SearchAttackLogResponse SearchAttackLog(SearchAttackLogRequest request) {
            return  new SearchAttackLogExecutor().Client(this).Execute<SearchAttackLogResponse, SearchAttackLogResult, SearchAttackLogRequest>(request);
        }
#else
        /// <summary>
        ///  攻击记录查询
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SearchAttackLogResponse> SearchAttackLog(SearchAttackLogRequest request) {
            return await new SearchAttackLogExecutor().Client(this).Execute<SearchAttackLogResponse, SearchAttackLogResult, SearchAttackLogRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  分地区及运营商查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryStatisticsDataGroupByAreaResponse QueryStatisticsDataGroupByArea(QueryStatisticsDataGroupByAreaRequest request) {
            return  new QueryStatisticsDataGroupByAreaExecutor().Client(this).Execute<QueryStatisticsDataGroupByAreaResponse, QueryStatisticsDataGroupByAreaResult, QueryStatisticsDataGroupByAreaRequest>(request);
        }
#else
        /// <summary>
        ///  分地区及运营商查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryStatisticsDataGroupByAreaResponse> QueryStatisticsDataGroupByArea(QueryStatisticsDataGroupByAreaRequest request) {
            return await new QueryStatisticsDataGroupByAreaExecutor().Client(this).Execute<QueryStatisticsDataGroupByAreaResponse, QueryStatisticsDataGroupByAreaResult, QueryStatisticsDataGroupByAreaRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置URL鉴权
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetLiveDomainAccessKeyResponse SetLiveDomainAccessKey(SetLiveDomainAccessKeyRequest request) {
            return  new SetLiveDomainAccessKeyExecutor().Client(this).Execute<SetLiveDomainAccessKeyResponse, SetLiveDomainAccessKeyResult, SetLiveDomainAccessKeyRequest>(request);
        }
#else
        /// <summary>
        ///  设置URL鉴权
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetLiveDomainAccessKeyResponse> SetLiveDomainAccessKey(SetLiveDomainAccessKeyRequest request) {
            return await new SetLiveDomainAccessKeyExecutor().Client(this).Execute<SetLiveDomainAccessKeyResponse, SetLiveDomainAccessKeyResult, SetLiveDomainAccessKeyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询WAF黑名单规则列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QuerywafBlackRulesResponse QuerywafBlackRules(QuerywafBlackRulesRequest request) {
            return  new QuerywafBlackRulesExecutor().Client(this).Execute<QuerywafBlackRulesResponse, QuerywafBlackRulesResult, QuerywafBlackRulesRequest>(request);
        }
#else
        /// <summary>
        ///  查询WAF黑名单规则列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QuerywafBlackRulesResponse> QuerywafBlackRules(QuerywafBlackRulesRequest request) {
            return await new QuerywafBlackRulesExecutor().Client(this).Execute<QuerywafBlackRulesResponse, QuerywafBlackRulesResult, QuerywafBlackRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除禁播流
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteForbiddenStreamResponse DeleteForbiddenStream(DeleteForbiddenStreamRequest request) {
            return  new DeleteForbiddenStreamExecutor().Client(this).Execute<DeleteForbiddenStreamResponse, DeleteForbiddenStreamResult, DeleteForbiddenStreamRequest>(request);
        }
#else
        /// <summary>
        ///  删除禁播流
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteForbiddenStreamResponse> DeleteForbiddenStream(DeleteForbiddenStreamRequest request) {
            return await new DeleteForbiddenStreamExecutor().Client(this).Execute<DeleteForbiddenStreamResponse, DeleteForbiddenStreamResult, DeleteForbiddenStreamRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  回源改写批量配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ConfigBackSourceRulesResponse ConfigBackSourceRules(ConfigBackSourceRulesRequest request) {
            return  new ConfigBackSourceRulesExecutor().Client(this).Execute<ConfigBackSourceRulesResponse, ConfigBackSourceRulesResult, ConfigBackSourceRulesRequest>(request);
        }
#else
        /// <summary>
        ///  回源改写批量配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ConfigBackSourceRulesResponse> ConfigBackSourceRules(ConfigBackSourceRulesRequest request) {
            return await new ConfigBackSourceRulesExecutor().Client(this).Execute<ConfigBackSourceRulesResponse, ConfigBackSourceRulesResult, ConfigBackSourceRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置WAF白名单开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetWafWhiteRuleSwitchResponse SetWafWhiteRuleSwitch(SetWafWhiteRuleSwitchRequest request) {
            return  new SetWafWhiteRuleSwitchExecutor().Client(this).Execute<SetWafWhiteRuleSwitchResponse, SetWafWhiteRuleSwitchResult, SetWafWhiteRuleSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  设置WAF白名单开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetWafWhiteRuleSwitchResponse> SetWafWhiteRuleSwitch(SetWafWhiteRuleSwitchRequest request) {
            return await new SetWafWhiteRuleSwitchExecutor().Client(this).Execute<SetWafWhiteRuleSwitchResponse, SetWafWhiteRuleSwitchResult, SetWafWhiteRuleSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据taskIds查询刷新预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryRefreshTaskByIdsResponse QueryRefreshTaskByIds(QueryRefreshTaskByIdsRequest request) {
            return  new QueryRefreshTaskByIdsExecutor().Client(this).Execute<QueryRefreshTaskByIdsResponse, QueryRefreshTaskByIdsResult, QueryRefreshTaskByIdsRequest>(request);
        }
#else
        /// <summary>
        ///  根据taskIds查询刷新预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryRefreshTaskByIdsResponse> QueryRefreshTaskByIds(QueryRefreshTaskByIdsRequest request) {
            return await new QueryRefreshTaskByIdsExecutor().Client(this).Execute<QueryRefreshTaskByIdsResponse, QueryRefreshTaskByIdsResult, QueryRefreshTaskByIdsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询统计数据并进行汇总加和
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryStatisticsDataGroupSumResponse QueryStatisticsDataGroupSum(QueryStatisticsDataGroupSumRequest request) {
            return  new QueryStatisticsDataGroupSumExecutor().Client(this).Execute<QueryStatisticsDataGroupSumResponse, QueryStatisticsDataGroupSumResult, QueryStatisticsDataGroupSumRequest>(request);
        }
#else
        /// <summary>
        ///  查询统计数据并进行汇总加和
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryStatisticsDataGroupSumResponse> QueryStatisticsDataGroupSum(QueryStatisticsDataGroupSumRequest request) {
            return await new QueryStatisticsDataGroupSumExecutor().Client(this).Execute<QueryStatisticsDataGroupSumResponse, QueryStatisticsDataGroupSumResult, QueryStatisticsDataGroupSumRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询域名的全部分类配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainAllConfigClassifyResponse QueryDomainAllConfigClassify(QueryDomainAllConfigClassifyRequest request) {
            return  new QueryDomainAllConfigClassifyExecutor().Client(this).Execute<QueryDomainAllConfigClassifyResponse, QueryDomainAllConfigClassifyResult, QueryDomainAllConfigClassifyRequest>(request);
        }
#else
        /// <summary>
        ///  查询域名的全部分类配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainAllConfigClassifyResponse> QueryDomainAllConfigClassify(QueryDomainAllConfigClassifyRequest request) {
            return await new QueryDomainAllConfigClassifyExecutor().Client(this).Execute<QueryDomainAllConfigClassifyResponse, QueryDomainAllConfigClassifyResult, QueryDomainAllConfigClassifyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  带宽查询接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryBandResponse QueryBand(QueryBandRequest request) {
            return  new QueryBandExecutor().Client(this).Execute<QueryBandResponse, QueryBandResult, QueryBandRequest>(request);
        }
#else
        /// <summary>
        ///  带宽查询接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryBandResponse> QueryBand(QueryBandRequest request) {
            return await new QueryBandExecutor().Client(this).Execute<QueryBandResponse, QueryBandResult, QueryBandRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  添加httpHeader
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetHttpHeaderResponse SetHttpHeader(SetHttpHeaderRequest request) {
            return  new SetHttpHeaderExecutor().Client(this).Execute<SetHttpHeaderResponse, SetHttpHeaderResult, SetHttpHeaderRequest>(request);
        }
#else
        /// <summary>
        ///  添加httpHeader
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetHttpHeaderResponse> SetHttpHeader(SetHttpHeaderRequest request) {
            return await new SetHttpHeaderExecutor().Client(this).Execute<SetHttpHeaderResponse, SetHttpHeaderResult, SetHttpHeaderRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询IP归属，适用于查询边缘节点，仅支持中国境内IP地址查询
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CheckWhetherIpBelongToJCloudResponse CheckWhetherIpBelongToJCloud(CheckWhetherIpBelongToJCloudRequest request) {
            return  new CheckWhetherIpBelongToJCloudExecutor().Client(this).Execute<CheckWhetherIpBelongToJCloudResponse, CheckWhetherIpBelongToJCloudResult, CheckWhetherIpBelongToJCloudRequest>(request);
        }
#else
        /// <summary>
        ///  查询IP归属，适用于查询边缘节点，仅支持中国境内IP地址查询
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CheckWhetherIpBelongToJCloudResponse> CheckWhetherIpBelongToJCloud(CheckWhetherIpBelongToJCloudRequest request) {
            return await new CheckWhetherIpBelongToJCloudExecutor().Client(this).Execute<CheckWhetherIpBelongToJCloudResponse, CheckWhetherIpBelongToJCloudResult, CheckWhetherIpBelongToJCloudRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询刷新任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryPurgeTaskResponse QueryPurgeTask(QueryPurgeTaskRequest request) {
            return  new QueryPurgeTaskExecutor().Client(this).Execute<QueryPurgeTaskResponse, QueryPurgeTaskResult, QueryPurgeTaskRequest>(request);
        }
#else
        /// <summary>
        ///  查询刷新任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryPurgeTaskResponse> QueryPurgeTask(QueryPurgeTaskRequest request) {
            return await new QueryPurgeTaskExecutor().Client(this).Execute<QueryPurgeTaskResponse, QueryPurgeTaskResult, QueryPurgeTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置gzip
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetGzipResponse SetGzip(SetGzipRequest request) {
            return  new SetGzipExecutor().Client(this).Execute<SetGzipResponse, SetGzipResult, SetGzipRequest>(request);
        }
#else
        /// <summary>
        ///  设置gzip
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetGzipResponse> SetGzip(SetGzipRequest request) {
            return await new SetGzipExecutor().Client(this).Execute<SetGzipResponse, SetGzipResult, SetGzipRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLiveStatisticsDataResponse QueryLiveStatisticsData(QueryLiveStatisticsDataRequest request) {
            return  new QueryLiveStatisticsDataExecutor().Client(this).Execute<QueryLiveStatisticsDataResponse, QueryLiveStatisticsDataResult, QueryLiveStatisticsDataRequest>(request);
        }
#else
        /// <summary>
        ///  查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLiveStatisticsDataResponse> QueryLiveStatisticsData(QueryLiveStatisticsDataRequest request) {
            return await new QueryLiveStatisticsDataExecutor().Client(this).Execute<QueryLiveStatisticsDataResponse, QueryLiveStatisticsDataResult, QueryLiveStatisticsDataRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量域名查询日志
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainsLogResponse QueryDomainsLog(QueryDomainsLogRequest request) {
            return  new QueryDomainsLogExecutor().Client(this).Execute<QueryDomainsLogResponse, QueryDomainsLogResult, QueryDomainsLogRequest>(request);
        }
#else
        /// <summary>
        ///  批量域名查询日志
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainsLogResponse> QueryDomainsLog(QueryDomainsLogRequest request) {
            return await new QueryDomainsLogExecutor().Client(this).Execute<QueryDomainsLogResponse, QueryDomainsLogResult, QueryDomainsLogRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  启用CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableCCProtectRuleResponse EnableCCProtectRule(EnableCCProtectRuleRequest request) {
            return  new EnableCCProtectRuleExecutor().Client(this).Execute<EnableCCProtectRuleResponse, EnableCCProtectRuleResult, EnableCCProtectRuleRequest>(request);
        }
#else
        /// <summary>
        ///  启用CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableCCProtectRuleResponse> EnableCCProtectRule(EnableCCProtectRuleRequest request) {
            return await new EnableCCProtectRuleExecutor().Client(this).Execute<EnableCCProtectRuleResponse, EnableCCProtectRuleResult, EnableCCProtectRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置域名refer
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetReferResponse SetRefer(SetReferRequest request) {
            return  new SetReferExecutor().Client(this).Execute<SetReferResponse, SetReferResult, SetReferRequest>(request);
        }
#else
        /// <summary>
        ///  设置域名refer
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetReferResponse> SetRefer(SetReferRequest request) {
            return await new SetReferExecutor().Client(this).Execute<SetReferResponse, SetReferResult, SetReferRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询直播域名详情v1
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLiveDomainDetailResponse QueryLiveDomainDetail(QueryLiveDomainDetailRequest request) {
            return  new QueryLiveDomainDetailExecutor().Client(this).Execute<QueryLiveDomainDetailResponse, QueryLiveDomainDetailResult, QueryLiveDomainDetailRequest>(request);
        }
#else
        /// <summary>
        ///  查询直播域名详情v1
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLiveDomainDetailResponse> QueryLiveDomainDetail(QueryLiveDomainDetailRequest request) {
            return await new QueryLiveDomainDetailExecutor().Client(this).Execute<QueryLiveDomainDetailResponse, QueryLiveDomainDetailResult, QueryLiveDomainDetailRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询waf ip黑名单配置状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryIpBlackSettingStatusResponse QueryIpBlackSettingStatus(QueryIpBlackSettingStatusRequest request) {
            return  new QueryIpBlackSettingStatusExecutor().Client(this).Execute<QueryIpBlackSettingStatusResponse, QueryIpBlackSettingStatusResult, QueryIpBlackSettingStatusRequest>(request);
        }
#else
        /// <summary>
        ///  查询waf ip黑名单配置状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryIpBlackSettingStatusResponse> QueryIpBlackSettingStatus(QueryIpBlackSettingStatusRequest request) {
            return await new QueryIpBlackSettingStatusExecutor().Client(this).Execute<QueryIpBlackSettingStatusResponse, QueryIpBlackSettingStatusResult, QueryIpBlackSettingStatusRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建修改模板实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ModifyDomainTempInstResponse ModifyDomainTempInst(ModifyDomainTempInstRequest request) {
            return  new ModifyDomainTempInstExecutor().Client(this).Execute<ModifyDomainTempInstResponse, ModifyDomainTempInstResult, ModifyDomainTempInstRequest>(request);
        }
#else
        /// <summary>
        ///  创建修改模板实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ModifyDomainTempInstResponse> ModifyDomainTempInst(ModifyDomainTempInstRequest request) {
            return await new ModifyDomainTempInstExecutor().Client(this).Execute<ModifyDomainTempInstResponse, ModifyDomainTempInstResult, ModifyDomainTempInstRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建直播预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateLiveDomainPrefecthTaskResponse CreateLiveDomainPrefecthTask(CreateLiveDomainPrefecthTaskRequest request) {
            return  new CreateLiveDomainPrefecthTaskExecutor().Client(this).Execute<CreateLiveDomainPrefecthTaskResponse, CreateLiveDomainPrefecthTaskResult, CreateLiveDomainPrefecthTaskRequest>(request);
        }
#else
        /// <summary>
        ///  创建直播预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateLiveDomainPrefecthTaskResponse> CreateLiveDomainPrefecthTask(CreateLiveDomainPrefecthTaskRequest request) {
            return await new CreateLiveDomainPrefecthTaskExecutor().Client(this).Execute<CreateLiveDomainPrefecthTaskResponse, CreateLiveDomainPrefecthTaskResult, CreateLiveDomainPrefecthTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询TOP IP，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryStatisticsTopIpResponse QueryStatisticsTopIp(QueryStatisticsTopIpRequest request) {
            return  new QueryStatisticsTopIpExecutor().Client(this).Execute<QueryStatisticsTopIpResponse, QueryStatisticsTopIpResult, QueryStatisticsTopIpRequest>(request);
        }
#else
        /// <summary>
        ///  查询TOP IP，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryStatisticsTopIpResponse> QueryStatisticsTopIp(QueryStatisticsTopIpRequest request) {
            return await new QueryStatisticsTopIpExecutor().Client(this).Execute<QueryStatisticsTopIpResponse, QueryStatisticsTopIpResult, QueryStatisticsTopIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询攻击记录详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public WafQueryAttackDetailsResponse WafQueryAttackDetails(WafQueryAttackDetailsRequest request) {
            return  new WafQueryAttackDetailsExecutor().Client(this).Execute<WafQueryAttackDetailsResponse, WafQueryAttackDetailsResult, WafQueryAttackDetailsRequest>(request);
        }
#else
        /// <summary>
        ///  查询攻击记录详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<WafQueryAttackDetailsResponse> WafQueryAttackDetails(WafQueryAttackDetailsRequest request) {
            return await new WafQueryAttackDetailsExecutor().Client(this).Execute<WafQueryAttackDetailsResponse, WafQueryAttackDetailsResult, WafQueryAttackDetailsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  停止源站监控
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopMonitorResponse StopMonitor(StopMonitorRequest request) {
            return  new StopMonitorExecutor().Client(this).Execute<StopMonitorResponse, StopMonitorResult, StopMonitorRequest>(request);
        }
#else
        /// <summary>
        ///  停止源站监控
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopMonitorResponse> StopMonitor(StopMonitorRequest request) {
            return await new StopMonitorExecutor().Client(this).Execute<StopMonitorResponse, StopMonitorResult, StopMonitorRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除修改模板实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DelDomainTempInstanceResponse DelDomainTempInstance(DelDomainTempInstanceRequest request) {
            return  new DelDomainTempInstanceExecutor().Client(this).Execute<DelDomainTempInstanceResponse, DelDomainTempInstanceResult, DelDomainTempInstanceRequest>(request);
        }
#else
        /// <summary>
        ///  删除修改模板实例
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DelDomainTempInstanceResponse> DelDomainTempInstance(DelDomainTempInstanceRequest request) {
            return await new DelDomainTempInstanceExecutor().Client(this).Execute<DelDomainTempInstanceResponse, DelDomainTempInstanceResult, DelDomainTempInstanceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询http header头
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryHttpHeaderResponse QueryHttpHeader(QueryHttpHeaderRequest request) {
            return  new QueryHttpHeaderExecutor().Client(this).Execute<QueryHttpHeaderResponse, QueryHttpHeaderResult, QueryHttpHeaderRequest>(request);
        }
#else
        /// <summary>
        ///  查询http header头
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryHttpHeaderResponse> QueryHttpHeader(QueryHttpHeaderRequest request) {
            return await new QueryHttpHeaderExecutor().Client(this).Execute<QueryHttpHeaderResponse, QueryHttpHeaderResult, QueryHttpHeaderRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询waf地域信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryWafRegionsResponse QueryWafRegions(QueryWafRegionsRequest request) {
            return  new QueryWafRegionsExecutor().Client(this).Execute<QueryWafRegionsResponse, QueryWafRegionsResult, QueryWafRegionsRequest>(request);
        }
#else
        /// <summary>
        ///  查询waf地域信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryWafRegionsResponse> QueryWafRegions(QueryWafRegionsRequest request) {
            return await new QueryWafRegionsExecutor().Client(this).Execute<QueryWafRegionsResponse, QueryWafRegionsResult, QueryWafRegionsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建刷新预热回调任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateRefreshTaskForCallbackV2Response CreateRefreshTaskForCallbackV2(CreateRefreshTaskForCallbackV2Request request) {
            return  new CreateRefreshTaskForCallbackV2Executor().Client(this).Execute<CreateRefreshTaskForCallbackV2Response, CreateRefreshTaskForCallbackV2Result, CreateRefreshTaskForCallbackV2Request>(request);
        }
#else
        /// <summary>
        ///  创建刷新预热回调任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateRefreshTaskForCallbackV2Response> CreateRefreshTaskForCallbackV2(CreateRefreshTaskForCallbackV2Request request) {
            return await new CreateRefreshTaskForCallbackV2Executor().Client(this).Execute<CreateRefreshTaskForCallbackV2Response, CreateRefreshTaskForCallbackV2Result, CreateRefreshTaskForCallbackV2Request>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询WAF总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryWafWhiteRuleSwitchResponse QueryWafWhiteRuleSwitch(QueryWafWhiteRuleSwitchRequest request) {
            return  new QueryWafWhiteRuleSwitchExecutor().Client(this).Execute<QueryWafWhiteRuleSwitchResponse, QueryWafWhiteRuleSwitchResult, QueryWafWhiteRuleSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  查询WAF总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryWafWhiteRuleSwitchResponse> QueryWafWhiteRuleSwitch(QueryWafWhiteRuleSwitchRequest request) {
            return await new QueryWafWhiteRuleSwitchExecutor().Client(this).Execute<QueryWafWhiteRuleSwitchResponse, QueryWafWhiteRuleSwitchResult, QueryWafWhiteRuleSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  新增一条CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateCCProtectRuleResponse CreateCCProtectRule(CreateCCProtectRuleRequest request) {
            return  new CreateCCProtectRuleExecutor().Client(this).Execute<CreateCCProtectRuleResponse, CreateCCProtectRuleResult, CreateCCProtectRuleRequest>(request);
        }
#else
        /// <summary>
        ///  新增一条CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateCCProtectRuleResponse> CreateCCProtectRule(CreateCCProtectRuleRequest request) {
            return await new CreateCCProtectRuleExecutor().Client(this).Execute<CreateCCProtectRuleResponse, CreateCCProtectRuleResult, CreateCCProtectRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询直播预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLivePrefetchTaskResponse QueryLivePrefetchTask(QueryLivePrefetchTaskRequest request) {
            return  new QueryLivePrefetchTaskExecutor().Client(this).Execute<QueryLivePrefetchTaskResponse, QueryLivePrefetchTaskResult, QueryLivePrefetchTaskRequest>(request);
        }
#else
        /// <summary>
        ///  查询直播预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLivePrefetchTaskResponse> QueryLivePrefetchTask(QueryLivePrefetchTaskRequest request) {
            return await new QueryLivePrefetchTaskExecutor().Client(this).Execute<QueryLivePrefetchTaskResponse, QueryLivePrefetchTaskResult, QueryLivePrefetchTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  新增一条白名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateWafWhiteRuleResponse CreateWafWhiteRule(CreateWafWhiteRuleRequest request) {
            return  new CreateWafWhiteRuleExecutor().Client(this).Execute<CreateWafWhiteRuleResponse, CreateWafWhiteRuleResult, CreateWafWhiteRuleRequest>(request);
        }
#else
        /// <summary>
        ///  新增一条白名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateWafWhiteRuleResponse> CreateWafWhiteRule(CreateWafWhiteRuleRequest request) {
            return await new CreateWafWhiteRuleExecutor().Client(this).Execute<CreateWafWhiteRuleResponse, CreateWafWhiteRuleResult, CreateWafWhiteRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查找地域运营商列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryAreaIspListV2Response QueryAreaIspListV2(QueryAreaIspListV2Request request) {
            return  new QueryAreaIspListV2Executor().Client(this).Execute<QueryAreaIspListV2Response, QueryAreaIspListV2Result, QueryAreaIspListV2Request>(request);
        }
#else
        /// <summary>
        ///  查找地域运营商列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryAreaIspListV2Response> QueryAreaIspListV2(QueryAreaIspListV2Request request) {
            return await new QueryAreaIspListV2Executor().Client(this).Execute<QueryAreaIspListV2Response, QueryAreaIspListV2Result, QueryAreaIspListV2Request>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询平均带宽
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryAvgBandwidthForPCdnResponse QueryAvgBandwidthForPCdn(QueryAvgBandwidthForPCdnRequest request) {
            return  new QueryAvgBandwidthForPCdnExecutor().Client(this).Execute<QueryAvgBandwidthForPCdnResponse, QueryAvgBandwidthForPCdnResult, QueryAvgBandwidthForPCdnRequest>(request);
        }
#else
        /// <summary>
        ///  查询平均带宽
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryAvgBandwidthForPCdnResponse> QueryAvgBandwidthForPCdn(QueryAvgBandwidthForPCdnRequest request) {
            return await new QueryAvgBandwidthForPCdnExecutor().Client(this).Execute<QueryAvgBandwidthForPCdnResponse, QueryAvgBandwidthForPCdnResult, QueryAvgBandwidthForPCdnRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询WAF白名单规则列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QuerywafWhiteRulesResponse QuerywafWhiteRules(QuerywafWhiteRulesRequest request) {
            return  new QuerywafWhiteRulesExecutor().Client(this).Execute<QuerywafWhiteRulesResponse, QuerywafWhiteRulesResult, QuerywafWhiteRulesRequest>(request);
        }
#else
        /// <summary>
        ///  查询WAF白名单规则列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QuerywafWhiteRulesResponse> QuerywafWhiteRules(QuerywafWhiteRulesRequest request) {
            return await new QuerywafWhiteRulesExecutor().Client(this).Execute<QuerywafWhiteRulesResponse, QuerywafWhiteRulesResult, QuerywafWhiteRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询自定义错误页面信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryCustomErrorPageResponse QueryCustomErrorPage(QueryCustomErrorPageRequest request) {
            return  new QueryCustomErrorPageExecutor().Client(this).Execute<QueryCustomErrorPageResponse, QueryCustomErrorPageResult, QueryCustomErrorPageRequest>(request);
        }
#else
        /// <summary>
        ///  查询自定义错误页面信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryCustomErrorPageResponse> QueryCustomErrorPage(QueryCustomErrorPageRequest request) {
            return await new QueryCustomErrorPageExecutor().Client(this).Execute<QueryCustomErrorPageResponse, QueryCustomErrorPageResult, QueryCustomErrorPageRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询日志
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainLogResponse QueryDomainLog(QueryDomainLogRequest request) {
            return  new QueryDomainLogExecutor().Client(this).Execute<QueryDomainLogResponse, QueryDomainLogResult, QueryDomainLogRequest>(request);
        }
#else
        /// <summary>
        ///  查询日志
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainLogResponse> QueryDomainLog(QueryDomainLogRequest request) {
            return await new QueryDomainLogExecutor().Client(this).Execute<QueryDomainLogResponse, QueryDomainLogResult, QueryDomainLogRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置http协议
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetHttpTypeResponse SetHttpType(SetHttpTypeRequest request) {
            return  new SetHttpTypeExecutor().Client(this).Execute<SetHttpTypeResponse, SetHttpTypeResult, SetHttpTypeRequest>(request);
        }
#else
        /// <summary>
        ///  设置http协议
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetHttpTypeResponse> SetHttpType(SetHttpTypeRequest request) {
            return await new SetHttpTypeExecutor().Client(this).Execute<SetHttpTypeResponse, SetHttpTypeResult, SetHttpTypeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询ip黑白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLiveDomainIpBlackWhiteListResponse QueryLiveDomainIpBlackWhiteList(QueryLiveDomainIpBlackWhiteListRequest request) {
            return  new QueryLiveDomainIpBlackWhiteListExecutor().Client(this).Execute<QueryLiveDomainIpBlackWhiteListResponse, QueryLiveDomainIpBlackWhiteListResult, QueryLiveDomainIpBlackWhiteListRequest>(request);
        }
#else
        /// <summary>
        ///  查询ip黑白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLiveDomainIpBlackWhiteListResponse> QueryLiveDomainIpBlackWhiteList(QueryLiveDomainIpBlackWhiteListRequest request) {
            return await new QueryLiveDomainIpBlackWhiteListExecutor().Client(this).Execute<QueryLiveDomainIpBlackWhiteListResponse, QueryLiveDomainIpBlackWhiteListResult, QueryLiveDomainIpBlackWhiteListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryExtraCacheTimeResponse QueryExtraCacheTime(QueryExtraCacheTimeRequest request) {
            return  new QueryExtraCacheTimeExecutor().Client(this).Execute<QueryExtraCacheTimeResponse, QueryExtraCacheTimeResult, QueryExtraCacheTimeRequest>(request);
        }
#else
        /// <summary>
        ///  查询异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryExtraCacheTimeResponse> QueryExtraCacheTime(QueryExtraCacheTimeRequest request) {
            return await new QueryExtraCacheTimeExecutor().Client(this).Execute<QueryExtraCacheTimeResponse, QueryExtraCacheTimeResult, QueryExtraCacheTimeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  停止预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopPrefetchTaskResponse StopPrefetchTask(StopPrefetchTaskRequest request) {
            return  new StopPrefetchTaskExecutor().Client(this).Execute<StopPrefetchTaskResponse, StopPrefetchTaskResult, StopPrefetchTaskRequest>(request);
        }
#else
        /// <summary>
        ///  停止预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopPrefetchTaskResponse> StopPrefetchTask(StopPrefetchTaskRequest request) {
            return await new StopPrefetchTaskExecutor().Client(this).Execute<StopPrefetchTaskResponse, StopPrefetchTaskResult, StopPrefetchTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询统计数据并进行汇总加和，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryMixTrafficGroupSumResponse QueryMixTrafficGroupSum(QueryMixTrafficGroupSumRequest request) {
            return  new QueryMixTrafficGroupSumExecutor().Client(this).Execute<QueryMixTrafficGroupSumResponse, QueryMixTrafficGroupSumResult, QueryMixTrafficGroupSumRequest>(request);
        }
#else
        /// <summary>
        ///  查询统计数据并进行汇总加和，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryMixTrafficGroupSumResponse> QueryMixTrafficGroupSum(QueryMixTrafficGroupSumRequest request) {
            return await new QueryMixTrafficGroupSumExecutor().Client(this).Execute<QueryMixTrafficGroupSumResponse, QueryMixTrafficGroupSumResult, QueryMixTrafficGroupSumRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询oss存储域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryOssBucketsResponse QueryOssBuckets(QueryOssBucketsRequest request) {
            return  new QueryOssBucketsExecutor().Client(this).Execute<QueryOssBucketsResponse, QueryOssBucketsResult, QueryOssBucketsRequest>(request);
        }
#else
        /// <summary>
        ///  查询oss存储域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryOssBucketsResponse> QueryOssBuckets(QueryOssBucketsRequest request) {
            return await new QueryOssBucketsExecutor().Client(this).Execute<QueryOssBucketsResponse, QueryOssBucketsResult, QueryOssBucketsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  攻击类型统计接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryAttackTypeCountResponse QueryAttackTypeCount(QueryAttackTypeCountRequest request) {
            return  new QueryAttackTypeCountExecutor().Client(this).Execute<QueryAttackTypeCountResponse, QueryAttackTypeCountResult, QueryAttackTypeCountRequest>(request);
        }
#else
        /// <summary>
        ///  攻击类型统计接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryAttackTypeCountResponse> QueryAttackTypeCount(QueryAttackTypeCountRequest request) {
            return await new QueryAttackTypeCountExecutor().Client(this).Execute<QueryAttackTypeCountResponse, QueryAttackTypeCountResult, QueryAttackTypeCountRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询解封状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryUnForbiddenStatusResponse QueryUnForbiddenStatus(QueryUnForbiddenStatusRequest request) {
            return  new QueryUnForbiddenStatusExecutor().Client(this).Execute<QueryUnForbiddenStatusResponse, QueryUnForbiddenStatusResult, QueryUnForbiddenStatusRequest>(request);
        }
#else
        /// <summary>
        ///  查询解封状态
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryUnForbiddenStatusResponse> QueryUnForbiddenStatus(QueryUnForbiddenStatusRequest request) {
            return await new QueryUnForbiddenStatusExecutor().Client(this).Execute<QueryUnForbiddenStatusResponse, QueryUnForbiddenStatusResult, QueryUnForbiddenStatusRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  dash鉴权设置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetAuthConfigResponse SetAuthConfig(SetAuthConfigRequest request) {
            return  new SetAuthConfigExecutor().Client(this).Execute<SetAuthConfigResponse, SetAuthConfigResult, SetAuthConfigRequest>(request);
        }
#else
        /// <summary>
        ///  dash鉴权设置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetAuthConfigResponse> SetAuthConfig(SetAuthConfigRequest request) {
            return await new SetAuthConfigExecutor().Client(this).Execute<SetAuthConfigResponse, SetAuthConfigResult, SetAuthConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询ip黑白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryIpBlackListResponse QueryIpBlackList(QueryIpBlackListRequest request) {
            return  new QueryIpBlackListExecutor().Client(this).Execute<QueryIpBlackListResponse, QueryIpBlackListResult, QueryIpBlackListRequest>(request);
        }
#else
        /// <summary>
        ///  查询ip黑白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryIpBlackListResponse> QueryIpBlackList(QueryIpBlackListRequest request) {
            return await new QueryIpBlackListExecutor().Client(this).Execute<QueryIpBlackListResponse, QueryIpBlackListResult, QueryIpBlackListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  回源改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ConfigBackSourceRuleResponse ConfigBackSourceRule(ConfigBackSourceRuleRequest request) {
            return  new ConfigBackSourceRuleExecutor().Client(this).Execute<ConfigBackSourceRuleResponse, ConfigBackSourceRuleResult, ConfigBackSourceRuleRequest>(request);
        }
#else
        /// <summary>
        ///  回源改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ConfigBackSourceRuleResponse> ConfigBackSourceRule(ConfigBackSourceRuleRequest request) {
            return await new ConfigBackSourceRuleExecutor().Client(this).Execute<ConfigBackSourceRuleResponse, ConfigBackSourceRuleResult, ConfigBackSourceRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置直播域名回源host
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetLiveDomainBackSourceHostResponse SetLiveDomainBackSourceHost(SetLiveDomainBackSourceHostRequest request) {
            return  new SetLiveDomainBackSourceHostExecutor().Client(this).Execute<SetLiveDomainBackSourceHostResponse, SetLiveDomainBackSourceHostResult, SetLiveDomainBackSourceHostRequest>(request);
        }
#else
        /// <summary>
        ///  设置直播域名回源host
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetLiveDomainBackSourceHostResponse> SetLiveDomainBackSourceHost(SetLiveDomainBackSourceHostRequest request) {
            return await new SetLiveDomainBackSourceHostExecutor().Client(this).Execute<SetLiveDomainBackSourceHostResponse, SetLiveDomainBackSourceHostResult, SetLiveDomainBackSourceHostRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteExtraCacheTimeResponse DeleteExtraCacheTime(DeleteExtraCacheTimeRequest request) {
            return  new DeleteExtraCacheTimeExecutor().Client(this).Execute<DeleteExtraCacheTimeResponse, DeleteExtraCacheTimeResult, DeleteExtraCacheTimeRequest>(request);
        }
#else
        /// <summary>
        ///  删除异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteExtraCacheTimeResponse> DeleteExtraCacheTime(DeleteExtraCacheTimeRequest request) {
            return await new DeleteExtraCacheTimeExecutor().Client(this).Execute<DeleteExtraCacheTimeResponse, DeleteExtraCacheTimeResult, DeleteExtraCacheTimeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置转协议
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetProtocolConvertResponse SetProtocolConvert(SetProtocolConvertRequest request) {
            return  new SetProtocolConvertExecutor().Client(this).Execute<SetProtocolConvertResponse, SetProtocolConvertResult, SetProtocolConvertRequest>(request);
        }
#else
        /// <summary>
        ///  设置转协议
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetProtocolConvertResponse> SetProtocolConvert(SetProtocolConvertRequest request) {
            return await new SetProtocolConvertExecutor().Client(this).Execute<SetProtocolConvertResponse, SetProtocolConvertResult, SetProtocolConvertRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询CC防护规则列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryCCProtectRulesResponse QueryCCProtectRules(QueryCCProtectRulesRequest request) {
            return  new QueryCCProtectRulesExecutor().Client(this).Execute<QueryCCProtectRulesResponse, QueryCCProtectRulesResult, QueryCCProtectRulesRequest>(request);
        }
#else
        /// <summary>
        ///  查询CC防护规则列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryCCProtectRulesResponse> QueryCCProtectRules(QueryCCProtectRulesRequest request) {
            return await new QueryCCProtectRulesExecutor().Client(this).Execute<QueryCCProtectRulesResponse, QueryCCProtectRulesResult, QueryCCProtectRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置加速区域
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetAccelerateRegionResponse SetAccelerateRegion(SetAccelerateRegionRequest request) {
            return  new SetAccelerateRegionExecutor().Client(this).Execute<SetAccelerateRegionResponse, SetAccelerateRegionResult, SetAccelerateRegionRequest>(request);
        }
#else
        /// <summary>
        ///  设置加速区域
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetAccelerateRegionResponse> SetAccelerateRegion(SetAccelerateRegionRequest request) {
            return await new SetAccelerateRegionExecutor().Client(this).Execute<SetAccelerateRegionResponse, SetAccelerateRegionResult, SetAccelerateRegionRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询加速域名接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetDomainListResponse GetDomainList(GetDomainListRequest request) {
            return  new GetDomainListExecutor().Client(this).Execute<GetDomainListResponse, GetDomainListResult, GetDomainListRequest>(request);
        }
#else
        /// <summary>
        ///  查询加速域名接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetDomainListResponse> GetDomainList(GetDomainListRequest request) {
            return await new GetDomainListExecutor().Client(this).Execute<GetDomainListResponse, GetDomainListResult, GetDomainListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置域名refer防盗链
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetLiveDomainReferResponse SetLiveDomainRefer(SetLiveDomainReferRequest request) {
            return  new SetLiveDomainReferExecutor().Client(this).Execute<SetLiveDomainReferResponse, SetLiveDomainReferResult, SetLiveDomainReferRequest>(request);
        }
#else
        /// <summary>
        ///  设置域名refer防盗链
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetLiveDomainReferResponse> SetLiveDomainRefer(SetLiveDomainReferRequest request) {
            return await new SetLiveDomainReferExecutor().Client(this).Execute<SetLiveDomainReferResponse, SetLiveDomainReferResult, SetLiveDomainReferRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置忽略参数
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetIgnoreQueryStringResponse SetIgnoreQueryString(SetIgnoreQueryStringRequest request) {
            return  new SetIgnoreQueryStringExecutor().Client(this).Execute<SetIgnoreQueryStringResponse, SetIgnoreQueryStringResult, SetIgnoreQueryStringRequest>(request);
        }
#else
        /// <summary>
        ///  设置忽略参数
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetIgnoreQueryStringResponse> SetIgnoreQueryString(SetIgnoreQueryStringRequest request) {
            return await new SetIgnoreQueryStringExecutor().Client(this).Execute<SetIgnoreQueryStringResponse, SetIgnoreQueryStringResult, SetIgnoreQueryStringRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量删除域名组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public BatchDeleteDomainGroupResponse BatchDeleteDomainGroup(BatchDeleteDomainGroupRequest request) {
            return  new BatchDeleteDomainGroupExecutor().Client(this).Execute<BatchDeleteDomainGroupResponse, BatchDeleteDomainGroupResult, BatchDeleteDomainGroupRequest>(request);
        }
#else
        /// <summary>
        ///  批量删除域名组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<BatchDeleteDomainGroupResponse> BatchDeleteDomainGroup(BatchDeleteDomainGroupRequest request) {
            return await new BatchDeleteDomainGroupExecutor().Client(this).Execute<BatchDeleteDomainGroupResponse, BatchDeleteDomainGroupResult, BatchDeleteDomainGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置userAgent信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetUserAgentConfigResponse SetUserAgentConfig(SetUserAgentConfigRequest request) {
            return  new SetUserAgentConfigExecutor().Client(this).Execute<SetUserAgentConfigResponse, SetUserAgentConfigResult, SetUserAgentConfigRequest>(request);
        }
#else
        /// <summary>
        ///  设置userAgent信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetUserAgentConfigResponse> SetUserAgentConfig(SetUserAgentConfigRequest request) {
            return await new SetUserAgentConfigExecutor().Client(this).Execute<SetUserAgentConfigResponse, SetUserAgentConfigResult, SetUserAgentConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  更新预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdatePrefetchTaskResponse UpdatePrefetchTask(UpdatePrefetchTaskRequest request) {
            return  new UpdatePrefetchTaskExecutor().Client(this).Execute<UpdatePrefetchTaskResponse, UpdatePrefetchTaskResult, UpdatePrefetchTaskRequest>(request);
        }
#else
        /// <summary>
        ///  更新预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdatePrefetchTaskResponse> UpdatePrefetchTask(UpdatePrefetchTaskRequest request) {
            return await new UpdatePrefetchTaskExecutor().Client(this).Execute<UpdatePrefetchTaskResponse, UpdatePrefetchTaskResult, UpdatePrefetchTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置网络防护层规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetNetProtectionRulesResponse SetNetProtectionRules(SetNetProtectionRulesRequest request) {
            return  new SetNetProtectionRulesExecutor().Client(this).Execute<SetNetProtectionRulesResponse, SetNetProtectionRulesResult, SetNetProtectionRulesRequest>(request);
        }
#else
        /// <summary>
        ///  设置网络防护层规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetNetProtectionRulesResponse> SetNetProtectionRules(SetNetProtectionRulesRequest request) {
            return await new SetNetProtectionRulesExecutor().Client(this).Execute<SetNetProtectionRulesResponse, SetNetProtectionRulesResult, SetNetProtectionRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置直播域名回源信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetLiveDomainBackSourceResponse SetLiveDomainBackSource(SetLiveDomainBackSourceRequest request) {
            return  new SetLiveDomainBackSourceExecutor().Client(this).Execute<SetLiveDomainBackSourceResponse, SetLiveDomainBackSourceResult, SetLiveDomainBackSourceRequest>(request);
        }
#else
        /// <summary>
        ///  设置直播域名回源信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetLiveDomainBackSourceResponse> SetLiveDomainBackSource(SetLiveDomainBackSourceRequest request) {
            return await new SetLiveDomainBackSourceExecutor().Client(this).Execute<SetLiveDomainBackSourceResponse, SetLiveDomainBackSourceResult, SetLiveDomainBackSourceRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置协议跟随回源
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetFollowSourceProtocolResponse SetFollowSourceProtocol(SetFollowSourceProtocolRequest request) {
            return  new SetFollowSourceProtocolExecutor().Client(this).Execute<SetFollowSourceProtocolResponse, SetFollowSourceProtocolResult, SetFollowSourceProtocolRequest>(request);
        }
#else
        /// <summary>
        ///  设置协议跟随回源
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetFollowSourceProtocolResponse> SetFollowSourceProtocol(SetFollowSourceProtocolRequest request) {
            return await new SetFollowSourceProtocolExecutor().Client(this).Execute<SetFollowSourceProtocolResponse, SetFollowSourceProtocolResult, SetFollowSourceProtocolRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看证书列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetSslCertListResponse GetSslCertList(GetSslCertListRequest request) {
            return  new GetSslCertListExecutor().Client(this).Execute<GetSslCertListResponse, GetSslCertListResult, GetSslCertListRequest>(request);
        }
#else
        /// <summary>
        ///  查看证书列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetSslCertListResponse> GetSslCertList(GetSslCertListRequest request) {
            return await new GetSslCertListExecutor().Client(this).Execute<GetSslCertListResponse, GetSslCertListResult, GetSslCertListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询Url改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryUrlRuleResponse QueryUrlRule(QueryUrlRuleRequest request) {
            return  new QueryUrlRuleExecutor().Client(this).Execute<QueryUrlRuleResponse, QueryUrlRuleResult, QueryUrlRuleRequest>(request);
        }
#else
        /// <summary>
        ///  查询Url改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryUrlRuleResponse> QueryUrlRule(QueryUrlRuleRequest request) {
            return await new QueryUrlRuleExecutor().Client(this).Execute<QueryUrlRuleResponse, QueryUrlRuleResult, QueryUrlRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建点播加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateDomainResponse CreateDomain(CreateDomainRequest request) {
            return  new CreateDomainExecutor().Client(this).Execute<CreateDomainResponse, CreateDomainResult, CreateDomainRequest>(request);
        }
#else
        /// <summary>
        ///  创建点播加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateDomainResponse> CreateDomain(CreateDomainRequest request) {
            return await new CreateDomainExecutor().Client(this).Execute<CreateDomainResponse, CreateDomainResult, CreateDomainRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询模板实例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainTempInstResponse QueryDomainTempInst(QueryDomainTempInstRequest request) {
            return  new QueryDomainTempInstExecutor().Client(this).Execute<QueryDomainTempInstResponse, QueryDomainTempInstResult, QueryDomainTempInstRequest>(request);
        }
#else
        /// <summary>
        ///  查询模板实例详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainTempInstResponse> QueryDomainTempInst(QueryDomainTempInstRequest request) {
            return await new QueryDomainTempInstExecutor().Client(this).Execute<QueryDomainTempInstResponse, QueryDomainTempInstResult, QueryDomainTempInstRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询一个域名的全部调度ip
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryServiceIpResponse QueryServiceIp(QueryServiceIpRequest request) {
            return  new QueryServiceIpExecutor().Client(this).Execute<QueryServiceIpResponse, QueryServiceIpResult, QueryServiceIpRequest>(request);
        }
#else
        /// <summary>
        ///  查询一个域名的全部调度ip
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryServiceIpResponse> QueryServiceIp(QueryServiceIpRequest request) {
            return await new QueryServiceIpExecutor().Client(this).Execute<QueryServiceIpResponse, QueryServiceIpResult, QueryServiceIpRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询域名配置信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainConfigResponse QueryDomainConfig(QueryDomainConfigRequest request) {
            return  new QueryDomainConfigExecutor().Client(this).Execute<QueryDomainConfigResponse, QueryDomainConfigResult, QueryDomainConfigRequest>(request);
        }
#else
        /// <summary>
        ///  查询域名配置信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainConfigResponse> QueryDomainConfig(QueryDomainConfigRequest request) {
            return await new QueryDomainConfigExecutor().Client(this).Execute<QueryDomainConfigResponse, QueryDomainConfigResult, QueryDomainConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询目录带宽，仅有部分用户支持该功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDirBandwidthResponse QueryDirBandwidth(QueryDirBandwidthRequest request) {
            return  new QueryDirBandwidthExecutor().Client(this).Execute<QueryDirBandwidthResponse, QueryDirBandwidthResult, QueryDirBandwidthRequest>(request);
        }
#else
        /// <summary>
        ///  查询目录带宽，仅有部分用户支持该功能
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDirBandwidthResponse> QueryDirBandwidth(QueryDirBandwidthRequest request) {
            return await new QueryDirBandwidthExecutor().Client(this).Execute<QueryDirBandwidthResponse, QueryDirBandwidthResult, QueryDirBandwidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量添加缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetCacheRulesResponse SetCacheRules(SetCacheRulesRequest request) {
            return  new SetCacheRulesExecutor().Client(this).Execute<SetCacheRulesResponse, SetCacheRulesResult, SetCacheRulesRequest>(request);
        }
#else
        /// <summary>
        ///  批量添加缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetCacheRulesResponse> SetCacheRules(SetCacheRulesRequest request) {
            return await new SetCacheRulesExecutor().Client(this).Execute<SetCacheRulesResponse, SetCacheRulesResult, SetCacheRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置视频拖拽
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetVideoDraftResponse SetVideoDraft(SetVideoDraftRequest request) {
            return  new SetVideoDraftExecutor().Client(this).Execute<SetVideoDraftResponse, SetVideoDraftResult, SetVideoDraftRequest>(request);
        }
#else
        /// <summary>
        ///  设置视频拖拽
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetVideoDraftResponse> SetVideoDraft(SetVideoDraftRequest request) {
            return await new SetVideoDraftExecutor().Client(this).Execute<SetVideoDraftResponse, SetVideoDraftResult, SetVideoDraftRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询CC 防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryCCProtectSwitchResponse QueryCCProtectSwitch(QueryCCProtectSwitchRequest request) {
            return  new QueryCCProtectSwitchExecutor().Client(this).Execute<QueryCCProtectSwitchResponse, QueryCCProtectSwitchResult, QueryCCProtectSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  查询CC 防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryCCProtectSwitchResponse> QueryCCProtectSwitch(QueryCCProtectSwitchRequest request) {
            return await new QueryCCProtectSwitchExecutor().Client(this).Execute<QueryCCProtectSwitchResponse, QueryCCProtectSwitchResult, QueryCCProtectSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  多path回源配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ConfigBackSourcePathResponse ConfigBackSourcePath(ConfigBackSourcePathRequest request) {
            return  new ConfigBackSourcePathExecutor().Client(this).Execute<ConfigBackSourcePathResponse, ConfigBackSourcePathResult, ConfigBackSourcePathRequest>(request);
        }
#else
        /// <summary>
        ///  多path回源配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ConfigBackSourcePathResponse> ConfigBackSourcePath(ConfigBackSourcePathRequest request) {
            return await new ConfigBackSourcePathExecutor().Client(this).Execute<ConfigBackSourcePathResponse, ConfigBackSourcePathResult, ConfigBackSourcePathRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateWebProtectSettingsResponse UpdateWebProtectSettings(UpdateWebProtectSettingsRequest request) {
            return  new UpdateWebProtectSettingsExecutor().Client(this).Execute<UpdateWebProtectSettingsResponse, UpdateWebProtectSettingsResult, UpdateWebProtectSettingsRequest>(request);
        }
#else
        /// <summary>
        ///  设置web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateWebProtectSettingsResponse> UpdateWebProtectSettings(UpdateWebProtectSettingsRequest request) {
            return await new UpdateWebProtectSettingsExecutor().Client(this).Execute<UpdateWebProtectSettingsResponse, UpdateWebProtectSettingsResult, UpdateWebProtectSettingsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  泛域名共享缓存
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public OperateShareCacheResponse OperateShareCache(OperateShareCacheRequest request) {
            return  new OperateShareCacheExecutor().Client(this).Execute<OperateShareCacheResponse, OperateShareCacheResult, OperateShareCacheRequest>(request);
        }
#else
        /// <summary>
        ///  泛域名共享缓存
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<OperateShareCacheResponse> OperateShareCache(OperateShareCacheRequest request) {
            return await new OperateShareCacheExecutor().Client(this).Execute<OperateShareCacheResponse, OperateShareCacheResult, OperateShareCacheRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  启用WAF白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableWafWhiteRulesResponse EnableWafWhiteRules(EnableWafWhiteRulesRequest request) {
            return  new EnableWafWhiteRulesExecutor().Client(this).Execute<EnableWafWhiteRulesResponse, EnableWafWhiteRulesResult, EnableWafWhiteRulesRequest>(request);
        }
#else
        /// <summary>
        ///  启用WAF白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableWafWhiteRulesResponse> EnableWafWhiteRules(EnableWafWhiteRulesRequest request) {
            return await new EnableWafWhiteRulesExecutor().Client(this).Execute<EnableWafWhiteRulesResponse, EnableWafWhiteRulesResult, EnableWafWhiteRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询用户刷新预热限额
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryRefreshLimitResponse QueryRefreshLimit(QueryRefreshLimitRequest request) {
            return  new QueryRefreshLimitExecutor().Client(this).Execute<QueryRefreshLimitResponse, QueryRefreshLimitResult, QueryRefreshLimitRequest>(request);
        }
#else
        /// <summary>
        ///  查询用户刷新预热限额
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryRefreshLimitResponse> QueryRefreshLimit(QueryRefreshLimitRequest request) {
            return await new QueryRefreshLimitExecutor().Client(this).Execute<QueryRefreshLimitResponse, QueryRefreshLimitResult, QueryRefreshLimitRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  分地区及运营商查询统计数据，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryMixStatisticsWithAreaDataResponse QueryMixStatisticsWithAreaData(QueryMixStatisticsWithAreaDataRequest request) {
            return  new QueryMixStatisticsWithAreaDataExecutor().Client(this).Execute<QueryMixStatisticsWithAreaDataResponse, QueryMixStatisticsWithAreaDataResult, QueryMixStatisticsWithAreaDataRequest>(request);
        }
#else
        /// <summary>
        ///  分地区及运营商查询统计数据，仅可查询中国境内的相关信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryMixStatisticsWithAreaDataResponse> QueryMixStatisticsWithAreaData(QueryMixStatisticsWithAreaDataRequest request) {
            return await new QueryMixStatisticsWithAreaDataExecutor().Client(this).Execute<QueryMixStatisticsWithAreaDataResponse, QueryMixStatisticsWithAreaDataResult, QueryMixStatisticsWithAreaDataRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetWebProtectSwitchResponse SetWebProtectSwitch(SetWebProtectSwitchRequest request) {
            return  new SetWebProtectSwitchExecutor().Client(this).Execute<SetWebProtectSwitchResponse, SetWebProtectSwitchResult, SetWebProtectSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  设置web防护开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetWebProtectSwitchResponse> SetWebProtectSwitch(SetWebProtectSwitchRequest request) {
            return await new SetWebProtectSwitchExecutor().Client(this).Execute<SetWebProtectSwitchResponse, SetWebProtectSwitchResult, SetWebProtectSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  开启或关闭ip黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public OperateLiveDomainIpBlackListResponse OperateLiveDomainIpBlackList(OperateLiveDomainIpBlackListRequest request) {
            return  new OperateLiveDomainIpBlackListExecutor().Client(this).Execute<OperateLiveDomainIpBlackListResponse, OperateLiveDomainIpBlackListResult, OperateLiveDomainIpBlackListRequest>(request);
        }
#else
        /// <summary>
        ///  开启或关闭ip黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<OperateLiveDomainIpBlackListResponse> OperateLiveDomainIpBlackList(OperateLiveDomainIpBlackListRequest request) {
            return await new OperateLiveDomainIpBlackListExecutor().Client(this).Execute<OperateLiveDomainIpBlackListResponse, OperateLiveDomainIpBlackListResult, OperateLiveDomainIpBlackListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  URL改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ConfigUrlRuleResponse ConfigUrlRule(ConfigUrlRuleRequest request) {
            return  new ConfigUrlRuleExecutor().Client(this).Execute<ConfigUrlRuleResponse, ConfigUrlRuleResult, ConfigUrlRuleRequest>(request);
        }
#else
        /// <summary>
        ///  URL改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ConfigUrlRuleResponse> ConfigUrlRule(ConfigUrlRuleRequest request) {
            return await new ConfigUrlRuleExecutor().Client(this).Execute<ConfigUrlRuleResponse, ConfigUrlRuleResult, ConfigUrlRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryStatisticsDataResponse QueryStatisticsData(QueryStatisticsDataRequest request) {
            return  new QueryStatisticsDataExecutor().Client(this).Execute<QueryStatisticsDataResponse, QueryStatisticsDataResult, QueryStatisticsDataRequest>(request);
        }
#else
        /// <summary>
        ///  查询统计数据
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryStatisticsDataResponse> QueryStatisticsData(QueryStatisticsDataRequest request) {
            return await new QueryStatisticsDataExecutor().Client(this).Execute<QueryStatisticsDataResponse, QueryStatisticsDataResult, QueryStatisticsDataRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查找地域运营商列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryAreaIspListResponse QueryAreaIspList(QueryAreaIspListRequest request) {
            return  new QueryAreaIspListExecutor().Client(this).Execute<QueryAreaIspListResponse, QueryAreaIspListResult, QueryAreaIspListRequest>(request);
        }
#else
        /// <summary>
        ///  查找地域运营商列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryAreaIspListResponse> QueryAreaIspList(QueryAreaIspListRequest request) {
            return await new QueryAreaIspListExecutor().Client(this).Execute<QueryAreaIspListResponse, QueryAreaIspListResult, QueryAreaIspListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除ccProtectRule
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteCCProtectRuleResponse DeleteCCProtectRule(DeleteCCProtectRuleRequest request) {
            return  new DeleteCCProtectRuleExecutor().Client(this).Execute<DeleteCCProtectRuleResponse, DeleteCCProtectRuleResult, DeleteCCProtectRuleRequest>(request);
        }
#else
        /// <summary>
        ///  删除ccProtectRule
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteCCProtectRuleResponse> DeleteCCProtectRule(DeleteCCProtectRuleRequest request) {
            return await new DeleteCCProtectRuleExecutor().Client(this).Execute<DeleteCCProtectRuleResponse, DeleteCCProtectRuleResult, DeleteCCProtectRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  分页查询直播流数据接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryStreamInfoResponse QueryStreamInfo(QueryStreamInfoRequest request) {
            return  new QueryStreamInfoExecutor().Client(this).Execute<QueryStreamInfoResponse, QueryStreamInfoResult, QueryStreamInfoRequest>(request);
        }
#else
        /// <summary>
        ///  分页查询直播流数据接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryStreamInfoResponse> QueryStreamInfo(QueryStreamInfoRequest request) {
            return await new QueryStreamInfoExecutor().Client(this).Execute<QueryStreamInfoResponse, QueryStreamInfoResult, QueryStreamInfoRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置WAF黑名单开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetWafBlackRuleSwitchResponse SetWafBlackRuleSwitch(SetWafBlackRuleSwitchRequest request) {
            return  new SetWafBlackRuleSwitchExecutor().Client(this).Execute<SetWafBlackRuleSwitchResponse, SetWafBlackRuleSwitchResult, SetWafBlackRuleSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  设置WAF黑名单开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetWafBlackRuleSwitchResponse> SetWafBlackRuleSwitch(SetWafBlackRuleSwitchRequest request) {
            return await new SetWafBlackRuleSwitchExecutor().Client(this).Execute<SetWafBlackRuleSwitchResponse, SetWafBlackRuleSwitchResult, SetWafBlackRuleSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询默认http header头部参数列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDefaultHttpHeaderKeyResponse QueryDefaultHttpHeaderKey(QueryDefaultHttpHeaderKeyRequest request) {
            return  new QueryDefaultHttpHeaderKeyExecutor().Client(this).Execute<QueryDefaultHttpHeaderKeyResponse, QueryDefaultHttpHeaderKeyResult, QueryDefaultHttpHeaderKeyRequest>(request);
        }
#else
        /// <summary>
        ///  查询默认http header头部参数列表
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDefaultHttpHeaderKeyResponse> QueryDefaultHttpHeaderKey(QueryDefaultHttpHeaderKeyRequest request) {
            return await new QueryDefaultHttpHeaderKeyExecutor().Client(this).Execute<QueryDefaultHttpHeaderKeyResponse, QueryDefaultHttpHeaderKeyResult, QueryDefaultHttpHeaderKeyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置源站监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetMonitorResponse SetMonitor(SetMonitorRequest request) {
            return  new SetMonitorExecutor().Client(this).Execute<SetMonitorResponse, SetMonitorResult, SetMonitorRequest>(request);
        }
#else
        /// <summary>
        ///  设置源站监控信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetMonitorResponse> SetMonitor(SetMonitorRequest request) {
            return await new SetMonitorExecutor().Client(this).Execute<SetMonitorResponse, SetMonitorResult, SetMonitorRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteDomainResponse DeleteDomain(DeleteDomainRequest request) {
            return  new DeleteDomainExecutor().Client(this).Execute<DeleteDomainResponse, DeleteDomainResult, DeleteDomainRequest>(request);
        }
#else
        /// <summary>
        ///  删除加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteDomainResponse> DeleteDomain(DeleteDomainRequest request) {
            return await new DeleteDomainExecutor().Client(this).Execute<DeleteDomainResponse, DeleteDomainResult, DeleteDomainRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询回源path
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryBackSourcePathResponse QueryBackSourcePath(QueryBackSourcePathRequest request) {
            return  new QueryBackSourcePathExecutor().Client(this).Execute<QueryBackSourcePathResponse, QueryBackSourcePathResult, QueryBackSourcePathRequest>(request);
        }
#else
        /// <summary>
        ///  查询回源path
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryBackSourcePathResponse> QueryBackSourcePath(QueryBackSourcePathRequest request) {
            return await new QueryBackSourcePathExecutor().Client(this).Execute<QueryBackSourcePathResponse, QueryBackSourcePathResult, QueryBackSourcePathRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询平均带宽
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryJBoxAvgBandwidthResponse QueryJBoxAvgBandwidth(QueryJBoxAvgBandwidthRequest request) {
            return  new QueryJBoxAvgBandwidthExecutor().Client(this).Execute<QueryJBoxAvgBandwidthResponse, QueryJBoxAvgBandwidthResult, QueryJBoxAvgBandwidthRequest>(request);
        }
#else
        /// <summary>
        ///  查询平均带宽
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryJBoxAvgBandwidthResponse> QueryJBoxAvgBandwidth(QueryJBoxAvgBandwidthRequest request) {
            return await new QueryJBoxAvgBandwidthExecutor().Client(this).Execute<QueryJBoxAvgBandwidthResponse, QueryJBoxAvgBandwidthResult, QueryJBoxAvgBandwidthRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  回源鉴权设置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetSourceAuthConfigResponse SetSourceAuthConfig(SetSourceAuthConfigRequest request) {
            return  new SetSourceAuthConfigExecutor().Client(this).Execute<SetSourceAuthConfigResponse, SetSourceAuthConfigResult, SetSourceAuthConfigRequest>(request);
        }
#else
        /// <summary>
        ///  回源鉴权设置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetSourceAuthConfigResponse> SetSourceAuthConfig(SetSourceAuthConfigRequest request) {
            return await new SetSourceAuthConfigExecutor().Client(this).Execute<SetSourceAuthConfigResponse, SetSourceAuthConfigResult, SetSourceAuthConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置userAgent信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryUserAgentResponse QueryUserAgent(QueryUserAgentRequest request) {
            return  new QueryUserAgentExecutor().Client(this).Execute<QueryUserAgentResponse, QueryUserAgentResult, QueryUserAgentRequest>(request);
        }
#else
        /// <summary>
        ///  设置userAgent信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryUserAgentResponse> QueryUserAgent(QueryUserAgentRequest request) {
            return await new QueryUserAgentExecutor().Client(this).Execute<QueryUserAgentResponse, QueryUserAgentResult, QueryUserAgentRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  通过标签查询加速域名接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetDomainListByFilterResponse GetDomainListByFilter(GetDomainListByFilterRequest request) {
            return  new GetDomainListByFilterExecutor().Client(this).Execute<GetDomainListByFilterResponse, GetDomainListByFilterResult, GetDomainListByFilterRequest>(request);
        }
#else
        /// <summary>
        ///  通过标签查询加速域名接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetDomainListByFilterResponse> GetDomainListByFilter(GetDomainListByFilterRequest request) {
            return await new GetDomainListByFilterExecutor().Client(this).Execute<GetDomainListByFilterResponse, GetDomainListByFilterResult, GetDomainListByFilterRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询总请求量与攻击请求量
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public WafQueryPvResponse WafQueryPv(WafQueryPvRequest request) {
            return  new WafQueryPvExecutor().Client(this).Execute<WafQueryPvResponse, WafQueryPvResult, WafQueryPvRequest>(request);
        }
#else
        /// <summary>
        ///  查询总请求量与攻击请求量
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<WafQueryPvResponse> WafQueryPv(WafQueryPvRequest request) {
            return await new WafQueryPvExecutor().Client(this).Execute<WafQueryPvResponse, WafQueryPvResult, WafQueryPvRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询回源302跳转信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryFollowRedirectResponse QueryFollowRedirect(QueryFollowRedirectRequest request) {
            return  new QueryFollowRedirectExecutor().Client(this).Execute<QueryFollowRedirectResponse, QueryFollowRedirectResult, QueryFollowRedirectRequest>(request);
        }
#else
        /// <summary>
        ///  查询回源302跳转信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryFollowRedirectResponse> QueryFollowRedirect(QueryFollowRedirectRequest request) {
            return await new QueryFollowRedirectExecutor().Client(this).Execute<QueryFollowRedirectResponse, QueryFollowRedirectResult, QueryFollowRedirectRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询用户推流域名app名/流名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryPushDomainORAppOrStreamResponse QueryPushDomainORAppOrStream(QueryPushDomainORAppOrStreamRequest request) {
            return  new QueryPushDomainORAppOrStreamExecutor().Client(this).Execute<QueryPushDomainORAppOrStreamResponse, QueryPushDomainORAppOrStreamResult, QueryPushDomainORAppOrStreamRequest>(request);
        }
#else
        /// <summary>
        ///  查询用户推流域名app名/流名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryPushDomainORAppOrStreamResponse> QueryPushDomainORAppOrStream(QueryPushDomainORAppOrStreamRequest request) {
            return await new QueryPushDomainORAppOrStreamExecutor().Client(this).Execute<QueryPushDomainORAppOrStreamResponse, QueryPushDomainORAppOrStreamResult, QueryPushDomainORAppOrStreamRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteCacheRuleResponse DeleteCacheRule(DeleteCacheRuleRequest request) {
            return  new DeleteCacheRuleExecutor().Client(this).Execute<DeleteCacheRuleResponse, DeleteCacheRuleResult, DeleteCacheRuleRequest>(request);
        }
#else
        /// <summary>
        ///  删除缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteCacheRuleResponse> DeleteCacheRule(DeleteCacheRuleRequest request) {
            return await new DeleteCacheRuleExecutor().Client(this).Execute<DeleteCacheRuleResponse, DeleteCacheRuleResult, DeleteCacheRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询网络防护层规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryNetProtectionRulesSwitchResponse QueryNetProtectionRulesSwitch(QueryNetProtectionRulesSwitchRequest request) {
            return  new QueryNetProtectionRulesSwitchExecutor().Client(this).Execute<QueryNetProtectionRulesSwitchResponse, QueryNetProtectionRulesSwitchResult, QueryNetProtectionRulesSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  查询网络防护层规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryNetProtectionRulesSwitchResponse> QueryNetProtectionRulesSwitch(QueryNetProtectionRulesSwitchRequest request) {
            return await new QueryNetProtectionRulesSwitchExecutor().Client(this).Execute<QueryNetProtectionRulesSwitchResponse, QueryNetProtectionRulesSwitchResult, QueryNetProtectionRulesSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询域名组接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainGroupListResponse QueryDomainGroupList(QueryDomainGroupListRequest request) {
            return  new QueryDomainGroupListExecutor().Client(this).Execute<QueryDomainGroupListResponse, QueryDomainGroupListResult, QueryDomainGroupListRequest>(request);
        }
#else
        /// <summary>
        ///  查询域名组接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainGroupListResponse> QueryDomainGroupList(QueryDomainGroupListRequest request) {
            return await new QueryDomainGroupListExecutor().Client(this).Execute<QueryDomainGroupListResponse, QueryDomainGroupListResult, QueryDomainGroupListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询未分组域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainsNotInGroupResponse QueryDomainsNotInGroup(QueryDomainsNotInGroupRequest request) {
            return  new QueryDomainsNotInGroupExecutor().Client(this).Execute<QueryDomainsNotInGroupResponse, QueryDomainsNotInGroupResult, QueryDomainsNotInGroupRequest>(request);
        }
#else
        /// <summary>
        ///  查询未分组域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainsNotInGroupResponse> QueryDomainsNotInGroup(QueryDomainsNotInGroupRequest request) {
            return await new QueryDomainsNotInGroupExecutor().Client(this).Execute<QueryDomainsNotInGroupResponse, QueryDomainsNotInGroupResult, QueryDomainsNotInGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryPrefetchTaskResponse QueryPrefetchTask(QueryPrefetchTaskRequest request) {
            return  new QueryPrefetchTaskExecutor().Client(this).Execute<QueryPrefetchTaskResponse, QueryPrefetchTaskResult, QueryPrefetchTaskRequest>(request);
        }
#else
        /// <summary>
        ///  查询预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryPrefetchTaskResponse> QueryPrefetchTask(QueryPrefetchTaskRequest request) {
            return await new QueryPrefetchTaskExecutor().Client(this).Execute<QueryPrefetchTaskResponse, QueryPrefetchTaskResult, QueryPrefetchTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  无线宝按条件查询的统计接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryJDBoxStatisticsDataResponse QueryJDBoxStatisticsData(QueryJDBoxStatisticsDataRequest request) {
            return  new QueryJDBoxStatisticsDataExecutor().Client(this).Execute<QueryJDBoxStatisticsDataResponse, QueryJDBoxStatisticsDataResult, QueryJDBoxStatisticsDataRequest>(request);
        }
#else
        /// <summary>
        ///  无线宝按条件查询的统计接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryJDBoxStatisticsDataResponse> QueryJDBoxStatisticsData(QueryJDBoxStatisticsDataRequest request) {
            return await new QueryJDBoxStatisticsDataExecutor().Client(this).Execute<QueryJDBoxStatisticsDataResponse, QueryJDBoxStatisticsDataResult, QueryJDBoxStatisticsDataRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询封禁信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryForbiddenInfoListResponse QueryForbiddenInfoList(QueryForbiddenInfoListRequest request) {
            return  new QueryForbiddenInfoListExecutor().Client(this).Execute<QueryForbiddenInfoListResponse, QueryForbiddenInfoListResult, QueryForbiddenInfoListRequest>(request);
        }
#else
        /// <summary>
        ///  查询封禁信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryForbiddenInfoListResponse> QueryForbiddenInfoList(QueryForbiddenInfoListRequest request) {
            return await new QueryForbiddenInfoListExecutor().Client(this).Execute<QueryForbiddenInfoListResponse, QueryForbiddenInfoListResult, QueryForbiddenInfoListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询协议跟随回源
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryFollowSourceProtocolResponse QueryFollowSourceProtocol(QueryFollowSourceProtocolRequest request) {
            return  new QueryFollowSourceProtocolExecutor().Client(this).Execute<QueryFollowSourceProtocolResponse, QueryFollowSourceProtocolResult, QueryFollowSourceProtocolRequest>(request);
        }
#else
        /// <summary>
        ///  查询协议跟随回源
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryFollowSourceProtocolResponse> QueryFollowSourceProtocol(QueryFollowSourceProtocolRequest request) {
            return await new QueryFollowSourceProtocolExecutor().Client(this).Execute<QueryFollowSourceProtocolResponse, QueryFollowSourceProtocolResult, QueryFollowSourceProtocolRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询模板实例列表接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDomainTempInstListResponse QueryDomainTempInstList(QueryDomainTempInstListRequest request) {
            return  new QueryDomainTempInstListExecutor().Client(this).Execute<QueryDomainTempInstListResponse, QueryDomainTempInstListResult, QueryDomainTempInstListRequest>(request);
        }
#else
        /// <summary>
        ///  查询模板实例列表接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDomainTempInstListResponse> QueryDomainTempInstList(QueryDomainTempInstListRequest request) {
            return await new QueryDomainTempInstListExecutor().Client(this).Execute<QueryDomainTempInstListResponse, QueryDomainTempInstListResult, QueryDomainTempInstListRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  更新域名组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateDomainGroupResponse UpdateDomainGroup(UpdateDomainGroupRequest request) {
            return  new UpdateDomainGroupExecutor().Client(this).Execute<UpdateDomainGroupResponse, UpdateDomainGroupResult, UpdateDomainGroupRequest>(request);
        }
#else
        /// <summary>
        ///  更新域名组
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateDomainGroupResponse> UpdateDomainGroup(UpdateDomainGroupRequest request) {
            return await new UpdateDomainGroupExecutor().Client(this).Execute<UpdateDomainGroupResponse, UpdateDomainGroupResult, UpdateDomainGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public BatCreatePrefetchTaskResponse BatCreatePrefetchTask(BatCreatePrefetchTaskRequest request) {
            return  new BatCreatePrefetchTaskExecutor().Client(this).Execute<BatCreatePrefetchTaskResponse, BatCreatePrefetchTaskResult, BatCreatePrefetchTaskRequest>(request);
        }
#else
        /// <summary>
        ///  创建预热任务接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<BatCreatePrefetchTaskResponse> BatCreatePrefetchTask(BatCreatePrefetchTaskRequest request) {
            return await new BatCreatePrefetchTaskExecutor().Client(this).Execute<BatCreatePrefetchTaskResponse, BatCreatePrefetchTaskResult, BatCreatePrefetchTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查看证书详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public GetSslCertDetailResponse GetSslCertDetail(GetSslCertDetailRequest request) {
            return  new GetSslCertDetailExecutor().Client(this).Execute<GetSslCertDetailResponse, GetSslCertDetailResult, GetSslCertDetailRequest>(request);
        }
#else
        /// <summary>
        ///  查看证书详情
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<GetSslCertDetailResponse> GetSslCertDetail(GetSslCertDetailRequest request) {
            return await new GetSslCertDetailExecutor().Client(this).Execute<GetSslCertDetailResponse, GetSslCertDetailResult, GetSslCertDetailRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  停止加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public StopDomainResponse StopDomain(StopDomainRequest request) {
            return  new StopDomainExecutor().Client(this).Execute<StopDomainResponse, StopDomainResult, StopDomainRequest>(request);
        }
#else
        /// <summary>
        ///  停止加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<StopDomainResponse> StopDomain(StopDomainRequest request) {
            return await new StopDomainExecutor().Client(this).Execute<StopDomainResponse, StopDomainResult, StopDomainRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询WAF总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryWafSwitchResponse QueryWafSwitch(QueryWafSwitchRequest request) {
            return  new QueryWafSwitchExecutor().Client(this).Execute<QueryWafSwitchResponse, QueryWafSwitchResult, QueryWafSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  查询WAF总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryWafSwitchResponse> QueryWafSwitch(QueryWafSwitchRequest request) {
            return await new QueryWafSwitchExecutor().Client(this).Execute<QueryWafSwitchResponse, QueryWafSwitchResult, QueryWafSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除封禁信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteForbiddenInfoResponse DeleteForbiddenInfo(DeleteForbiddenInfoRequest request) {
            return  new DeleteForbiddenInfoExecutor().Client(this).Execute<DeleteForbiddenInfoResponse, DeleteForbiddenInfoResult, DeleteForbiddenInfoRequest>(request);
        }
#else
        /// <summary>
        ///  删除封禁信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteForbiddenInfoResponse> DeleteForbiddenInfo(DeleteForbiddenInfoRequest request) {
            return await new DeleteForbiddenInfoExecutor().Client(this).Execute<DeleteForbiddenInfoResponse, DeleteForbiddenInfoResult, DeleteForbiddenInfoRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  配置服务通知接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ConfigServiceNoticeResponse ConfigServiceNotice(ConfigServiceNoticeRequest request) {
            return  new ConfigServiceNoticeExecutor().Client(this).Execute<ConfigServiceNoticeResponse, ConfigServiceNoticeResult, ConfigServiceNoticeRequest>(request);
        }
#else
        /// <summary>
        ///  配置服务通知接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ConfigServiceNoticeResponse> ConfigServiceNotice(ConfigServiceNoticeRequest request) {
            return await new ConfigServiceNoticeExecutor().Client(this).Execute<ConfigServiceNoticeResponse, ConfigServiceNoticeResult, ConfigServiceNoticeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建刷新预热任务，
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateRefreshTaskResponse CreateRefreshTask(CreateRefreshTaskRequest request) {
            return  new CreateRefreshTaskExecutor().Client(this).Execute<CreateRefreshTaskResponse, CreateRefreshTaskResult, CreateRefreshTaskRequest>(request);
        }
#else
        /// <summary>
        ///  创建刷新预热任务，
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateRefreshTaskResponse> CreateRefreshTask(CreateRefreshTaskRequest request) {
            return await new CreateRefreshTaskExecutor().Client(this).Execute<CreateRefreshTaskResponse, CreateRefreshTaskResult, CreateRefreshTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询网络防护层规则接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryNetProtectionRulesResponse QueryNetProtectionRules(QueryNetProtectionRulesRequest request) {
            return  new QueryNetProtectionRulesExecutor().Client(this).Execute<QueryNetProtectionRulesResponse, QueryNetProtectionRulesResult, QueryNetProtectionRulesRequest>(request);
        }
#else
        /// <summary>
        ///  查询网络防护层规则接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryNetProtectionRulesResponse> QueryNetProtectionRules(QueryNetProtectionRulesRequest request) {
            return await new QueryNetProtectionRulesExecutor().Client(this).Execute<QueryNetProtectionRulesResponse, QueryNetProtectionRulesResult, QueryNetProtectionRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  预览证书
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public PreviewCertificateResponse PreviewCertificate(PreviewCertificateRequest request) {
            return  new PreviewCertificateExecutor().Client(this).Execute<PreviewCertificateResponse, PreviewCertificateResult, PreviewCertificateRequest>(request);
        }
#else
        /// <summary>
        ///  预览证书
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<PreviewCertificateResponse> PreviewCertificate(PreviewCertificateRequest request) {
            return await new PreviewCertificateExecutor().Client(this).Execute<PreviewCertificateResponse, PreviewCertificateResult, PreviewCertificateRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询回源改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryBackSourceRuleResponse QueryBackSourceRule(QueryBackSourceRuleRequest request) {
            return  new QueryBackSourceRuleExecutor().Client(this).Execute<QueryBackSourceRuleResponse, QueryBackSourceRuleResult, QueryBackSourceRuleRequest>(request);
        }
#else
        /// <summary>
        ///  查询回源改写配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryBackSourceRuleResponse> QueryBackSourceRule(QueryBackSourceRuleRequest request) {
            return await new QueryBackSourceRuleExecutor().Client(this).Execute<QueryBackSourceRuleResponse, QueryBackSourceRuleResult, QueryBackSourceRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  DDOS攻击报表接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryDdosGraphResponse QueryDdosGraph(QueryDdosGraphRequest request) {
            return  new QueryDdosGraphExecutor().Client(this).Execute<QueryDdosGraphResponse, QueryDdosGraphResult, QueryDdosGraphRequest>(request);
        }
#else
        /// <summary>
        ///  DDOS攻击报表接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryDdosGraphResponse> QueryDdosGraph(QueryDdosGraphRequest request) {
            return await new QueryDdosGraphExecutor().Client(this).Execute<QueryDdosGraphResponse, QueryDdosGraphResult, QueryDdosGraphRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除WAF黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteWafBlackRulesResponse DeleteWafBlackRules(DeleteWafBlackRulesRequest request) {
            return  new DeleteWafBlackRulesExecutor().Client(this).Execute<DeleteWafBlackRulesResponse, DeleteWafBlackRulesResult, DeleteWafBlackRulesRequest>(request);
        }
#else
        /// <summary>
        ///  删除WAF黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteWafBlackRulesResponse> DeleteWafBlackRules(DeleteWafBlackRulesRequest request) {
            return await new DeleteWafBlackRulesExecutor().Client(this).Execute<DeleteWafBlackRulesResponse, DeleteWafBlackRulesResult, DeleteWafBlackRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询回源改写批量配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryBackSourceRulesResponse QueryBackSourceRules(QueryBackSourceRulesRequest request) {
            return  new QueryBackSourceRulesExecutor().Client(this).Execute<QueryBackSourceRulesResponse, QueryBackSourceRulesResult, QueryBackSourceRulesRequest>(request);
        }
#else
        /// <summary>
        ///  查询回源改写批量配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryBackSourceRulesResponse> QueryBackSourceRules(QueryBackSourceRulesRequest request) {
            return await new QueryBackSourceRulesExecutor().Client(this).Execute<QueryBackSourceRulesResponse, QueryBackSourceRulesResult, QueryBackSourceRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  无线宝按group查询的统计接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryJDBoxStatisticsDataWithGroupResponse QueryJDBoxStatisticsDataWithGroup(QueryJDBoxStatisticsDataWithGroupRequest request) {
            return  new QueryJDBoxStatisticsDataWithGroupExecutor().Client(this).Execute<QueryJDBoxStatisticsDataWithGroupResponse, QueryJDBoxStatisticsDataWithGroupResult, QueryJDBoxStatisticsDataWithGroupRequest>(request);
        }
#else
        /// <summary>
        ///  无线宝按group查询的统计接口
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryJDBoxStatisticsDataWithGroupResponse> QueryJDBoxStatisticsDataWithGroup(QueryJDBoxStatisticsDataWithGroupRequest request) {
            return await new QueryJDBoxStatisticsDataWithGroupExecutor().Client(this).Execute<QueryJDBoxStatisticsDataWithGroupResponse, QueryJDBoxStatisticsDataWithGroupResult, QueryJDBoxStatisticsDataWithGroupRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改指定的黑名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateWafBlackRuleResponse UpdateWafBlackRule(UpdateWafBlackRuleRequest request) {
            return  new UpdateWafBlackRuleExecutor().Client(this).Execute<UpdateWafBlackRuleResponse, UpdateWafBlackRuleResult, UpdateWafBlackRuleRequest>(request);
        }
#else
        /// <summary>
        ///  修改指定的黑名单规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateWafBlackRuleResponse> UpdateWafBlackRule(UpdateWafBlackRuleRequest request) {
            return await new UpdateWafBlackRuleExecutor().Client(this).Execute<UpdateWafBlackRuleResponse, UpdateWafBlackRuleResult, UpdateWafBlackRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  启用WAF黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public EnableWafBlackRulesResponse EnableWafBlackRules(EnableWafBlackRulesRequest request) {
            return  new EnableWafBlackRulesExecutor().Client(this).Execute<EnableWafBlackRulesResponse, EnableWafBlackRulesResult, EnableWafBlackRulesRequest>(request);
        }
#else
        /// <summary>
        ///  启用WAF黑名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<EnableWafBlackRulesResponse> EnableWafBlackRules(EnableWafBlackRulesRequest request) {
            return await new EnableWafBlackRulesExecutor().Client(this).Execute<EnableWafBlackRulesResponse, EnableWafBlackRulesResult, EnableWafBlackRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询url鉴权
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryAccesskeyConfigResponse QueryAccesskeyConfig(QueryAccesskeyConfigRequest request) {
            return  new QueryAccesskeyConfigExecutor().Client(this).Execute<QueryAccesskeyConfigResponse, QueryAccesskeyConfigResult, QueryAccesskeyConfigRequest>(request);
        }
#else
        /// <summary>
        ///  查询url鉴权
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryAccesskeyConfigResponse> QueryAccesskeyConfig(QueryAccesskeyConfigRequest request) {
            return await new QueryAccesskeyConfigExecutor().Client(this).Execute<QueryAccesskeyConfigResponse, QueryAccesskeyConfigResult, QueryAccesskeyConfigRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  禁用CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DisableCCProtectRuleResponse DisableCCProtectRule(DisableCCProtectRuleRequest request) {
            return  new DisableCCProtectRuleExecutor().Client(this).Execute<DisableCCProtectRuleResponse, DisableCCProtectRuleResult, DisableCCProtectRuleRequest>(request);
        }
#else
        /// <summary>
        ///  禁用CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DisableCCProtectRuleResponse> DisableCCProtectRule(DisableCCProtectRuleRequest request) {
            return await new DisableCCProtectRuleExecutor().Client(this).Execute<DisableCCProtectRuleResponse, DisableCCProtectRuleResult, DisableCCProtectRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建刷新预热回调任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateRefreshTaskForCallbackResponse CreateRefreshTaskForCallback(CreateRefreshTaskForCallbackRequest request) {
            return  new CreateRefreshTaskForCallbackExecutor().Client(this).Execute<CreateRefreshTaskForCallbackResponse, CreateRefreshTaskForCallbackResult, CreateRefreshTaskForCallbackRequest>(request);
        }
#else
        /// <summary>
        ///  创建刷新预热回调任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateRefreshTaskForCallbackResponse> CreateRefreshTaskForCallback(CreateRefreshTaskForCallbackRequest request) {
            return await new CreateRefreshTaskForCallbackExecutor().Client(this).Execute<CreateRefreshTaskForCallbackResponse, CreateRefreshTaskForCallbackResult, CreateRefreshTaskForCallbackRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  域名一键复制配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public ExecuteDomainCopyResponse ExecuteDomainCopy(ExecuteDomainCopyRequest request) {
            return  new ExecuteDomainCopyExecutor().Client(this).Execute<ExecuteDomainCopyResponse, ExecuteDomainCopyResult, ExecuteDomainCopyRequest>(request);
        }
#else
        /// <summary>
        ///  域名一键复制配置
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<ExecuteDomainCopyResponse> ExecuteDomainCopy(ExecuteDomainCopyRequest request) {
            return await new ExecuteDomainCopyExecutor().Client(this).Execute<ExecuteDomainCopyResponse, ExecuteDomainCopyResult, ExecuteDomainCopyRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  操作刷新任务接口(包含创建、停止刷新任务)
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public OperatePurgeTaskResponse OperatePurgeTask(OperatePurgeTaskRequest request) {
            return  new OperatePurgeTaskExecutor().Client(this).Execute<OperatePurgeTaskResponse, OperatePurgeTaskResult, OperatePurgeTaskRequest>(request);
        }
#else
        /// <summary>
        ///  操作刷新任务接口(包含创建、停止刷新任务)
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<OperatePurgeTaskResponse> OperatePurgeTask(OperatePurgeTaskRequest request) {
            return await new OperatePurgeTaskExecutor().Client(this).Execute<OperatePurgeTaskResponse, OperatePurgeTaskResult, OperatePurgeTaskRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建点播加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public BatchCreateResponse BatchCreate(BatchCreateRequest request) {
            return  new BatchCreateExecutor().Client(this).Execute<BatchCreateResponse, BatchCreateResult, BatchCreateRequest>(request);
        }
#else
        /// <summary>
        ///  创建点播加速域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<BatchCreateResponse> BatchCreate(BatchCreateRequest request) {
            return await new BatchCreateExecutor().Client(this).Execute<BatchCreateResponse, BatchCreateResult, BatchCreateRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询统计数据并进行汇总加和
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryLiveTrafficGroupSumResponse QueryLiveTrafficGroupSum(QueryLiveTrafficGroupSumRequest request) {
            return  new QueryLiveTrafficGroupSumExecutor().Client(this).Execute<QueryLiveTrafficGroupSumResponse, QueryLiveTrafficGroupSumResult, QueryLiveTrafficGroupSumRequest>(request);
        }
#else
        /// <summary>
        ///  查询统计数据并进行汇总加和
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryLiveTrafficGroupSumResponse> QueryLiveTrafficGroupSum(QueryLiveTrafficGroupSumRequest request) {
            return await new QueryLiveTrafficGroupSumExecutor().Client(this).Execute<QueryLiveTrafficGroupSumResponse, QueryLiveTrafficGroupSumResult, QueryLiveTrafficGroupSumRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  删除WAF白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public DeleteWafWhiteRulesResponse DeleteWafWhiteRules(DeleteWafWhiteRulesRequest request) {
            return  new DeleteWafWhiteRulesExecutor().Client(this).Execute<DeleteWafWhiteRulesResponse, DeleteWafWhiteRulesResult, DeleteWafWhiteRulesRequest>(request);
        }
#else
        /// <summary>
        ///  删除WAF白名单
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<DeleteWafWhiteRulesResponse> DeleteWafWhiteRules(DeleteWafWhiteRulesRequest request) {
            return await new DeleteWafWhiteRulesExecutor().Client(this).Execute<DeleteWafWhiteRulesResponse, DeleteWafWhiteRulesResult, DeleteWafWhiteRulesRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置过滤参数
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetFilterArgsResponse SetFilterArgs(SetFilterArgsRequest request) {
            return  new SetFilterArgsExecutor().Client(this).Execute<SetFilterArgsResponse, SetFilterArgsResult, SetFilterArgsRequest>(request);
        }
#else
        /// <summary>
        ///  设置过滤参数
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetFilterArgsResponse> SetFilterArgs(SetFilterArgsRequest request) {
            return await new SetFilterArgsExecutor().Client(this).Execute<SetFilterArgsResponse, SetFilterArgsResult, SetFilterArgsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateCCProtectRuleResponse UpdateCCProtectRule(UpdateCCProtectRuleRequest request) {
            return  new UpdateCCProtectRuleExecutor().Client(this).Execute<UpdateCCProtectRuleResponse, UpdateCCProtectRuleResult, UpdateCCProtectRuleRequest>(request);
        }
#else
        /// <summary>
        ///  修改CC防护规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateCCProtectRuleResponse> UpdateCCProtectRule(UpdateCCProtectRuleRequest request) {
            return await new UpdateCCProtectRuleExecutor().Client(this).Execute<UpdateCCProtectRuleResponse, UpdateCCProtectRuleResult, UpdateCCProtectRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置封禁
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateForbiddenInfoResponse CreateForbiddenInfo(CreateForbiddenInfoRequest request) {
            return  new CreateForbiddenInfoExecutor().Client(this).Execute<CreateForbiddenInfoResponse, CreateForbiddenInfoResult, CreateForbiddenInfoRequest>(request);
        }
#else
        /// <summary>
        ///  设置封禁
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateForbiddenInfoResponse> CreateForbiddenInfo(CreateForbiddenInfoRequest request) {
            return await new CreateForbiddenInfoExecutor().Client(this).Execute<CreateForbiddenInfoResponse, CreateForbiddenInfoResult, CreateForbiddenInfoRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置线上计费方式
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryOnlineBillingTypeResponse QueryOnlineBillingType(QueryOnlineBillingTypeRequest request) {
            return  new QueryOnlineBillingTypeExecutor().Client(this).Execute<QueryOnlineBillingTypeResponse, QueryOnlineBillingTypeResult, QueryOnlineBillingTypeRequest>(request);
        }
#else
        /// <summary>
        ///  设置线上计费方式
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryOnlineBillingTypeResponse> QueryOnlineBillingType(QueryOnlineBillingTypeRequest request) {
            return await new QueryOnlineBillingTypeExecutor().Client(this).Execute<QueryOnlineBillingTypeResponse, QueryOnlineBillingTypeResult, QueryOnlineBillingTypeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  批量设置异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public BatchSetExtraCacheTimeResponse BatchSetExtraCacheTime(BatchSetExtraCacheTimeRequest request) {
            return  new BatchSetExtraCacheTimeExecutor().Client(this).Execute<BatchSetExtraCacheTimeResponse, BatchSetExtraCacheTimeResult, BatchSetExtraCacheTimeRequest>(request);
        }
#else
        /// <summary>
        ///  批量设置异常码缓存时间
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<BatchSetExtraCacheTimeResponse> BatchSetExtraCacheTime(BatchSetExtraCacheTimeRequest request) {
            return await new BatchSetExtraCacheTimeExecutor().Client(this).Execute<BatchSetExtraCacheTimeResponse, BatchSetExtraCacheTimeResult, BatchSetExtraCacheTimeRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  根据taskId查询刷新预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryRefreshTaskByIdResponse QueryRefreshTaskById(QueryRefreshTaskByIdRequest request) {
            return  new QueryRefreshTaskByIdExecutor().Client(this).Execute<QueryRefreshTaskByIdResponse, QueryRefreshTaskByIdResult, QueryRefreshTaskByIdRequest>(request);
        }
#else
        /// <summary>
        ///  根据taskId查询刷新预热任务
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryRefreshTaskByIdResponse> QueryRefreshTaskById(QueryRefreshTaskByIdRequest request) {
            return await new QueryRefreshTaskByIdExecutor().Client(this).Execute<QueryRefreshTaskByIdResponse, QueryRefreshTaskByIdResult, QueryRefreshTaskByIdRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  修改缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UpdateCacheRuleResponse UpdateCacheRule(UpdateCacheRuleRequest request) {
            return  new UpdateCacheRuleExecutor().Client(this).Execute<UpdateCacheRuleResponse, UpdateCacheRuleResult, UpdateCacheRuleRequest>(request);
        }
#else
        /// <summary>
        ///  修改缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UpdateCacheRuleResponse> UpdateCacheRule(UpdateCacheRuleRequest request) {
            return await new UpdateCacheRuleExecutor().Client(this).Execute<UpdateCacheRuleResponse, UpdateCacheRuleResult, UpdateCacheRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置WAF总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetWafSwitchResponse SetWafSwitch(SetWafSwitchRequest request) {
            return  new SetWafSwitchExecutor().Client(this).Execute<SetWafSwitchResponse, SetWafSwitchResult, SetWafSwitchRequest>(request);
        }
#else
        /// <summary>
        ///  设置WAF总开关
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetWafSwitchResponse> SetWafSwitch(SetWafSwitchRequest request) {
            return await new SetWafSwitchExecutor().Client(this).Execute<SetWafSwitchResponse, SetWafSwitchResult, SetWafSwitchRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  查询保留参数信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public QueryFilterArgsResponse QueryFilterArgs(QueryFilterArgsRequest request) {
            return  new QueryFilterArgsExecutor().Client(this).Execute<QueryFilterArgsResponse, QueryFilterArgsResult, QueryFilterArgsRequest>(request);
        }
#else
        /// <summary>
        ///  查询保留参数信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<QueryFilterArgsResponse> QueryFilterArgs(QueryFilterArgsRequest request) {
            return await new QueryFilterArgsExecutor().Client(this).Execute<QueryFilterArgsResponse, QueryFilterArgsResult, QueryFilterArgsRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  上传证书
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public UploadCertResponse UploadCert(UploadCertRequest request) {
            return  new UploadCertExecutor().Client(this).Execute<UploadCertResponse, UploadCertResult, UploadCertRequest>(request);
        }
#else
        /// <summary>
        ///  上传证书
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<UploadCertResponse> UploadCert(UploadCertRequest request) {
            return await new UploadCertExecutor().Client(this).Execute<UploadCertResponse, UploadCertResult, UploadCertRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  添加缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public CreateCacheRuleResponse CreateCacheRule(CreateCacheRuleRequest request) {
            return  new CreateCacheRuleExecutor().Client(this).Execute<CreateCacheRuleResponse, CreateCacheRuleResult, CreateCacheRuleRequest>(request);
        }
#else
        /// <summary>
        ///  添加缓存规则
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<CreateCacheRuleResponse> CreateCacheRule(CreateCacheRuleRequest request) {
            return await new CreateCacheRuleExecutor().Client(this).Execute<CreateCacheRuleResponse, CreateCacheRuleResult, CreateCacheRuleRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  创建直播域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public BatchCreateLiveDomainResponse BatchCreateLiveDomain(BatchCreateLiveDomainRequest request) {
            return  new BatchCreateLiveDomainExecutor().Client(this).Execute<BatchCreateLiveDomainResponse, BatchCreateLiveDomainResult, BatchCreateLiveDomainRequest>(request);
        }
#else
        /// <summary>
        ///  创建直播域名
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<BatchCreateLiveDomainResponse> BatchCreateLiveDomain(BatchCreateLiveDomainRequest request) {
            return await new BatchCreateLiveDomainExecutor().Client(this).Execute<BatchCreateLiveDomainResponse, BatchCreateLiveDomainResult, BatchCreateLiveDomainRequest>(request).ConfigureAwait(false);
        }
#endif
#if NET40||NET35
        /// <summary>
        ///  设置源站信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public SetSourceResponse SetSource(SetSourceRequest request) {
            return  new SetSourceExecutor().Client(this).Execute<SetSourceResponse, SetSourceResult, SetSourceRequest>(request);
        }
#else
        /// <summary>
        ///  设置源站信息
        /// </summary>
        /// <param name="request">请求参数信息</param>
        /// <returns>请求结果信息</returns>
        public async Task<SetSourceResponse> SetSource(SetSourceRequest request) {
            return await new SetSourceExecutor().Client(this).Execute<SetSourceResponse, SetSourceResult, SetSourceRequest>(request).ConfigureAwait(false);
        }
#endif

            /// <summary>
            ///  默认CdnClient 构造器 接口
            ///</summary>
            public interface Builder
            {

                /// <summary>
                /// 设置认证信息参数
                /// </summary>
                /// <param name="provider">认证信息提供对象</param>
                /// <returns>cdnClient 构造器</returns>
                Builder CredentialsProvider(CredentialsProvider provider);

                /// <summary>
                /// 设置请求环境参数
                /// </summary>
                /// <param name="environment">环境参数信息</param>
                /// <returns>cdnClient 构造器</returns>
                Builder Environment(Core.Client.SDKEnvironment environment);

                /// <summary>
                /// http 请求配置信息
                /// </summary>
                /// <param name="config">http 请求配置信息</param>
                /// <returns>cdnClient 构造器</returns>
                Builder HttpRequestConfig(HttpRequestConfig config);

                /// <summary>
                ///  构造CdnClient 对象
                ///</summary>
                CdnClient Build();
            }

            /// <summary>
            ///  默认CdnClient 构造器
            ///</summary>
            public class DefaultBuilder : Builder
            {
                /// <summary>
                ///  CdnClient service client
                /// </summary>
                private  CdnClient cdnClient;

                /// <summary>
                ///  默认CdnClient 构造器构造对象
                ///</summary>
                public DefaultBuilder()
                {
                    cdnClient = new CdnClient();
                }

                /// <summary>
                ///  构造CdnClient 对象
                ///</summary>
                public CdnClient Build()
                {
                    if (cdnClient.CredentialsProvider == null)
                    {
                        //if credentialsProvider not set, try load jdcloud global default  credentials provider
                        cdnClient.credentialsProvider = JdCloud.DefaultInstance.GetCredentialsProvider();
                        if (cdnClient.credentialsProvider == null)
                        {
                            throw new ArgumentNullException("CdnClient build error: jdcloud credentials provider not set");
                        }
                    }
                    if (cdnClient.HttpRequestConfig == null)
                    {
                        cdnClient.httpRequestConfig = JdCloud.DefaultInstance.GetHttpRequestConfig();
                        if (cdnClient.httpRequestConfig == null)
                        {
                        throw new ArgumentNullException("CdnClient build error: http request config not set");
                        }
                    }
                    return cdnClient;
                }

                /// <summary>
                /// 设置认证信息参数
                /// </summary>
                /// <param name="provider">认证信息提供对象</param>
                /// <returns>cdnClient 构造器</returns>
                public Builder CredentialsProvider(CredentialsProvider provider)
                {
                    cdnClient.credentialsProvider = provider;
                    return this;
                }

                /// <summary>
                /// 设置请求环境参数
                /// </summary>
                /// <param name="environment">环境参数信息</param>
                /// <returns>cdnClient 构造器</returns>
                public Builder Environment(SDKEnvironment environment)
                {
                    cdnClient.environment = environment;
                    return this;
                }

                /// <summary>
                /// http 请求配置信息
                /// </summary>
                /// <param name="config">http 请求配置信息</param>
                /// <returns>cdnClient 构造器</returns>
                public Builder HttpRequestConfig(HttpRequestConfig config)
                {
                    cdnClient.httpRequestConfig = config;
                    return this;
                }
            }
    }
}
